Sign upLogin

wafo-project/pywafo

View on GitHub
Star
src/wafo/polynomial.py

Summary

Maintainability
F
4 days
Test Coverage

Use of assert detected. The enclosed code will be removed when compiling to optimised byte code.
Open

    assert(np.all(abs(p(t) / q(t) - np.exp(t)) < 0.3))
Severity: Info
Found in src/wafo/polynomial.py by bandit

File polynomial.py has 1993 lines of code (exceeds 1000 allowed). Consider refactoring.
Open

"""
    Extended functions to operate on polynomials
"""
# ------------------------------------------------------------------------
# Name:        polynomial
Severity: Major
Found in src/wafo/polynomial.py - About 3 days to fix

    Function poly2str has a Cognitive Complexity of 32 (exceeds 15 allowed). Consider refactoring.
    Open

    def poly2str(p, variable='x'):
    """
    Return polynomial as a string.

    Parameters
    Severity: Minor
    Found in src/wafo/polynomial.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

    Function poly2hstr has a Cognitive Complexity of 28 (exceeds 15 allowed). Consider refactoring.
    Open

    def poly2hstr(p, variable='x'):
    """
    Return polynomial as a Horner represented string.

    Parameters
    Severity: Minor
    Found in src/wafo/polynomial.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

    Cheb1d has 21 functions (exceeds 20 allowed). Consider refactoring.
    Open

    class Cheb1d(object):
    coeffs = None
    order = None
    a = None
    b = None
    Severity: Minor
    Found in src/wafo/polynomial.py - About 2 hrs to fix

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

      def main():
    exp = np.exp
    [c1, c2] = padefitlsq(exp, 3, 3, 0, 2)

    x = np.linspace(0, 4)
      Severity: Minor
      Found in src/wafo/polynomial.py - About 1 hr to fix

        Function padefitlsq has a Cognitive Complexity of 20 (exceeds 15 allowed). Consider refactoring.
        Open

        def padefitlsq(fun, m, k, a=-1, b=1, trace=False, x=None, end_points=True):
    """
    Rational polynomial fitting. A minimax solution by least squares.

    Parameters
        Severity: Minor
        Found in src/wafo/polynomial.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 polyint has a Cognitive Complexity of 18 (exceeds 15 allowed). Consider refactoring.
        Open

        def polyint(p, m=1, k=None):
    """
    Return an antiderivative (indefinite integral) of a polynomial.

    The returned order `m` antiderivative `P` of polynomial `p` satisfies
        Severity: Minor
        Found in src/wafo/polynomial.py - About 45 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 padefitlsq has 8 arguments (exceeds 7 allowed). Consider refactoring.
        Open

        def padefitlsq(fun, m, k, a=-1, b=1, trace=False, x=None, end_points=True):
        Severity: Major
        Found in src/wafo/polynomial.py - About 35 mins to fix

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

          def poly2str(p, variable='x'):
          Severity: Critical
          Found in src/wafo/polynomial.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

          Function "padefitlsq" has 8 parameters, which is greater than the 7 authorized.
          Open

          def padefitlsq(fun, m, k, a=-1, b=1, trace=False, x=None, end_points=True):
          Severity: Major
          Found in src/wafo/polynomial.py by sonar-python

          A long parameter list can indicate that a new structure should be created to wrap the numerous parameters or that the function is doing too many things.

          Noncompliant Code Example

          With a maximum number of 4 parameters:

          def do_something(param1, param2, param3, param4, param5):
    ...

          Compliant Solution

          def do_something(param1, param2, param3, param4):
    ...

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

          def polyint(p, m=1, k=None):
          Severity: Critical
          Found in src/wafo/polynomial.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 20 to the 15 allowed.
          Open

          def padefitlsq(fun, m, k, a=-1, b=1, trace=False, x=None, end_points=True):
          Severity: Critical
          Found in src/wafo/polynomial.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 28 to the 15 allowed.
          Open

          def poly2hstr(p, variable='x'):
          Severity: Critical
          Found in src/wafo/polynomial.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

          Remove this commented out code.
          Open

              # n = 2
          Severity: Major
          Found in src/wafo/polynomial.py by sonar-python

          Programmers should not comment out code as it bloats programs and reduces readability.

          Unused code should be deleted and can be retrieved from source control history if required.

          See

          • MISRA C:2004, 2.4 - Sections of code should not be "commented out".
          • MISRA C++:2008, 2-7-2 - Sections of code shall not be "commented out" using C-style comments.
          • MISRA C++:2008, 2-7-3 - Sections of code should not be "commented out" using C++ comments.
          • MISRA C:2012, Dir. 4.4 - Sections of code should not be "commented out"

          Remove this commented out code.
          Open

              # v2d = np.polynomial.chebyshev.chebvander2d(xgrid, ygrid,
          Severity: Major
          Found in src/wafo/polynomial.py by sonar-python

          Programmers should not comment out code as it bloats programs and reduces readability.

          Unused code should be deleted and can be retrieved from source control history if required.

          See

          • MISRA C:2004, 2.4 - Sections of code should not be "commented out".
          • MISRA C++:2008, 2-7-2 - Sections of code shall not be "commented out" using C-style comments.
          • MISRA C++:2008, 2-7-3 - Sections of code should not be "commented out" using C++ comments.
          • MISRA C:2012, Dir. 4.4 - Sections of code should not be "commented out"

          Remove this commented out code.
          Open

              # x = chebroot(n=64, kind=1)
          Severity: Major
          Found in src/wafo/polynomial.py by sonar-python

          Programmers should not comment out code as it bloats programs and reduces readability.

          Unused code should be deleted and can be retrieved from source control history if required.

          See

          • MISRA C:2004, 2.4 - Sections of code should not be "commented out".
          • MISRA C++:2008, 2-7-2 - Sections of code shall not be "commented out" using C-style comments.
          • MISRA C++:2008, 2-7-3 - Sections of code should not be "commented out" using C++ comments.
          • MISRA C:2012, Dir. 4.4 - Sections of code should not be "commented out"

          Remove this commented out code.
          Open

                  # test_interpolate()
          Severity: Major
          Found in src/wafo/polynomial.py by sonar-python

          Programmers should not comment out code as it bloats programs and reduces readability.

          Unused code should be deleted and can be retrieved from source control history if required.

          See

          • MISRA C:2004, 2.4 - Sections of code should not be "commented out".
          • MISRA C++:2008, 2-7-2 - Sections of code shall not be "commented out" using C-style comments.
          • MISRA C++:2008, 2-7-3 - Sections of code should not be "commented out" using C++ comments.
          • MISRA C:2012, Dir. 4.4 - Sections of code should not be "commented out"

          Remove this commented out code.
          Open

              # xi = np.array(xi, copy=0) + 0.0
          Severity: Major
          Found in src/wafo/polynomial.py by sonar-python

          Programmers should not comment out code as it bloats programs and reduces readability.

          Unused code should be deleted and can be retrieved from source control history if required.

          See

          • MISRA C:2004, 2.4 - Sections of code should not be "commented out".
          • MISRA C++:2008, 2-7-2 - Sections of code shall not be "commented out" using C-style comments.
          • MISRA C++:2008, 2-7-3 - Sections of code should not be "commented out" using C++ comments.
          • MISRA C:2012, Dir. 4.4 - Sections of code should not be "commented out"

          Remove this commented out code.
          Open

                  # ind = self.order - key
          Severity: Major
          Found in src/wafo/polynomial.py by sonar-python

          Programmers should not comment out code as it bloats programs and reduces readability.

          Unused code should be deleted and can be retrieved from source control history if required.

          See

          • MISRA C:2004, 2.4 - Sections of code should not be "commented out".
          • MISRA C++:2008, 2-7-2 - Sections of code shall not be "commented out" using C-style comments.
          • MISRA C++:2008, 2-7-3 - Sections of code should not be "commented out" using C++ comments.
          • MISRA C:2012, Dir. 4.4 - Sections of code should not be "commented out"

          Remove this commented out code.
          Open

              # c = chebfit(f, n=n)[::-1]
          Severity: Major
          Found in src/wafo/polynomial.py by sonar-python

          Programmers should not comment out code as it bloats programs and reduces readability.

          Unused code should be deleted and can be retrieved from source control history if required.

          See

          • MISRA C:2004, 2.4 - Sections of code should not be "commented out".
          • MISRA C++:2008, 2-7-2 - Sections of code shall not be "commented out" using C-style comments.
          • MISRA C++:2008, 2-7-3 - Sections of code should not be "commented out" using C++ comments.
          • MISRA C:2012, Dir. 4.4 - Sections of code should not be "commented out"

          Remove this commented out code.
          Open

              # ys = np.dot(p[0, :], PL)  # smoothed y
          Severity: Major
          Found in src/wafo/polynomial.py by sonar-python

          Programmers should not comment out code as it bloats programs and reduces readability.

          Unused code should be deleted and can be retrieved from source control history if required.

          See

          • MISRA C:2004, 2.4 - Sections of code should not be "commented out".
          • MISRA C++:2008, 2-7-2 - Sections of code shall not be "commented out" using C-style comments.
          • MISRA C++:2008, 2-7-3 - Sections of code should not be "commented out" using C++ comments.
          • MISRA C:2012, Dir. 4.4 - Sections of code should not be "commented out"

          Remove this commented out code.
          Open

                  # return getattr(self, name)
          Severity: Major
          Found in src/wafo/polynomial.py by sonar-python

          Programmers should not comment out code as it bloats programs and reduces readability.

          Unused code should be deleted and can be retrieved from source control history if required.

          See

          • MISRA C:2004, 2.4 - Sections of code should not be "commented out".
          • MISRA C++:2008, 2-7-2 - Sections of code shall not be "commented out" using C-style comments.
          • MISRA C++:2008, 2-7-3 - Sections of code should not be "commented out" using C++ comments.
          • MISRA C:2012, Dir. 4.4 - Sections of code should not be "commented out"

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

              def f(x, y):
          Severity: Major
          Found in src/wafo/polynomial.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):
    ...

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

              def f(x):
          Severity: Major
          Found in src/wafo/polynomial.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