Sign upLogin

alchemyst/Skogestad-Python

View on GitHub
Star
robustcontrol/utils.py

Summary

Maintainability
F
1 wk
Test Coverage

File utils.py has 2314 lines of code (exceeds 250 allowed). Consider refactoring.
Open

# -*- coding: utf-8 -*-
"""
Created on Jan 27, 2012

@author: Carl Sandrock
Severity: Major
Found in robustcontrol/utils.py - About 6 days to fix

    Function scaling has a Cognitive Complexity of 46 (exceeds 5 allowed). Consider refactoring.
    Open

    def scaling(G_hat, e, u, input_type='symbolic', Gd_hat=None, d=None):
    """
    Receives symbolic matrix of plant and disturbance transfer functions
    as well as array of maximum deviations, scales plant variables according
    to eq () and ()
    Severity: Minor
    Found in robustcontrol/utils.py - About 7 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 scaling. (22)
    Open

    def scaling(G_hat, e, u, input_type='symbolic', Gd_hat=None, d=None):
    """
    Receives symbolic matrix of plant and disturbance transfer functions
    as well as array of maximum deviations, scales plant variables according
    to eq () and ()
    Severity: Minor
    Found in robustcontrol/utils.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 multi_polylcm has a Cognitive Complexity of 30 (exceeds 5 allowed). Consider refactoring.
    Open

    def multi_polylcm(P):
    roots_list = [i.r.tolist() for i in P]
    roots_by_mult = []
    lcm_roots_by_mult = []
    for roots in roots_list:
    Severity: Minor
    Found in robustcontrol/utils.py - About 4 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 tf_step has a Cognitive Complexity of 26 (exceeds 5 allowed). Consider refactoring.
    Open

    def tf_step(G, t_end=10, initial_val=0, points=1000,
            constraint=None, Y=None, method='numeric'):
    """
    Validate the step response data of a transfer function by considering dead
    time and constraints. A unit step response is generated.
    Severity: Minor
    Found in robustcontrol/utils.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 zeros has a Cognitive Complexity of 24 (exceeds 5 allowed). Consider refactoring.
    Open

    def zeros(G=None, A=None, B=None, C=None, D=None):
    """
    Return the zeros of a multivariable transfer function system for with
    transfer functions or state-space. For transfer functions, Theorem 4.5
    (p139) is used. For state-space, the method from Equations 4.66 and 4.67
    Severity: Minor
    Found in robustcontrol/utils.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 multi_polylcm. (15)
    Open

    def multi_polylcm(P):
    roots_list = [i.r.tolist() for i in P]
    roots_by_mult = []
    lcm_roots_by_mult = []
    for roots in roots_list:
    Severity: Minor
    Found in robustcontrol/utils.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 pole_zero_directions has a Cognitive Complexity of 23 (exceeds 5 allowed). Consider refactoring.
    Open

    def pole_zero_directions(G, vec, dir_type, display_type='a', e=1E-8, z_tol=1E-4, p_tol=1E-4):
    """
    Crude method to calculate the input and output direction of a pole or zero,
    from the SVD.
    Severity: Minor
    Found in robustcontrol/utils.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 tf2ss. (14)
    Open

    def tf2ss(H):
    """
    Converts a mimotf object to the controllable canonical form state space
    representation. This method and the examples were obtained from course work
    notes available at
    Severity: Minor
    Found in robustcontrol/utils.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 pole_zero_directions. (13)
    Open

    def pole_zero_directions(G, vec, dir_type, display_type='a', e=1E-8, z_tol=1E-4, p_tol=1E-4):
    """
    Crude method to calculate the input and output direction of a pole or zero,
    from the SVD.
    Severity: Minor
    Found in robustcontrol/utils.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 num_denom. (13)
    Open

    def num_denom(A, symbolic_expr=False):

    sym_den = 0
    sym_num = 0
    s = sympy.Symbol('s')
    Severity: Minor
    Found in robustcontrol/utils.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 zeros. (12)
    Open

    def zeros(G=None, A=None, B=None, C=None, D=None):
    """
    Return the zeros of a multivariable transfer function system for with
    transfer functions or state-space. For transfer functions, Theorem 4.5
    (p139) is used. For state-space, the method from Equations 4.66 and 4.67
    Severity: Minor
    Found in robustcontrol/utils.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 num_denom has a Cognitive Complexity of 20 (exceeds 5 allowed). Consider refactoring.
    Open

    def num_denom(A, symbolic_expr=False):

    sym_den = 0
    sym_num = 0
    s = sympy.Symbol('s')
    Severity: Minor
    Found in robustcontrol/utils.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

    tf has 24 functions (exceeds 20 allowed). Consider refactoring.
    Open

    class tf(object):
    """
    Very basic transfer function object

    Construct with a numerator and denominator:
    Severity: Minor
    Found in robustcontrol/utils.py - About 2 hrs to fix

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

      def tf_step(G, t_end=10, initial_val=0, points=1000,
            constraint=None, Y=None, method='numeric'):
    """
    Validate the step response data of a transfer function by considering dead
    time and constraints. A unit step response is generated.
      Severity: Minor
      Found in robustcontrol/utils.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

      mimotf has 22 functions (exceeds 20 allowed). Consider refactoring.
      Open

      class mimotf(object):
    """ Represents MIMO transfer function matrix

    This is a pretty basic wrapper around the numpy.matrix class which deals
    with most of the heavy lifting.
      Severity: Minor
      Found in robustcontrol/utils.py - About 2 hrs to fix

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

        def zero_directions_ss(A, B, C, D):
    """
    This function calculates the zeros with input and output directions from
    a state space representation using the method outlined on pg. 140
        Severity: Minor
        Found in robustcontrol/utils.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 method step. (7)
        Open

            def step(self, u_input, t_start=0, t_end=100, points=1000):
        """
        Calculate the time domian step response of a mimotf object.
        
        Parameters:
        Severity: Minor
        Found in robustcontrol/utils.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 det. (6)
        Open

        def det(A):
    """
    Calculate determinant via elementary operations

    :param A: Array-like object
        Severity: Minor
        Found in robustcontrol/utils.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 sym2mimotf. (6)
        Open

        def sym2mimotf(Gmat, deadtime=None):
    """Converts a MIMO transfer function system in sympy.Matrix form to a
    mimotf object making use of individual tf objects.

    Parameters
        Severity: Minor
        Found in robustcontrol/utils.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 minors. (6)
        Open

        def minors(G, order):
    """
    Returns the order minors of a MIMO tf G.
    """
    retlist = []
        Severity: Minor
        Found in robustcontrol/utils.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 minimal_realisation. (6)
        Open

        def minimal_realisation(a, b, c):
    """"This function will obtain a minimal realisation for a state space
    model in the form given in Skogestad second edition p 119 equations
    4.3 and 4.4
        Severity: Minor
        Found in robustcontrol/utils.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 poles_and_zeros_of_square_tf_matrix. (6)
        Open

        def poles_and_zeros_of_square_tf_matrix(G):
    """
    Determine poles and zeros of a square mimotf matrix, making use of the determinant.
    This method may fail in special cases. If terms cancel out during calculation of the determinant,
    not all poles and zeros will be determined.
        Severity: Minor
        Found in robustcontrol/utils.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 sym2mimotf has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
        Open

        def sym2mimotf(Gmat, deadtime=None):
    """Converts a MIMO transfer function system in sympy.Matrix form to a
    mimotf object making use of individual tf objects.

    Parameters
        Severity: Minor
        Found in robustcontrol/utils.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 poles_and_zeros_of_square_tf_matrix has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
        Open

        def poles_and_zeros_of_square_tf_matrix(G):
    """
    Determine poles and zeros of a square mimotf matrix, making use of the determinant.
    This method may fail in special cases. If terms cancel out during calculation of the determinant,
    not all poles and zeros will be determined.
        Severity: Minor
        Found in robustcontrol/utils.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 common_roots_ind has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
        Open

        def common_roots_ind(a, b, dec=3):
    #Returns the indices of common (approximately equal) roots
    #of two polynomials
    a_ind = []  # Contains index of common roots
    b_ind = []
        Severity: Minor
        Found in robustcontrol/utils.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 minimal_realisation has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
        Open

        def minimal_realisation(a, b, c):
    """"This function will obtain a minimal realisation for a state space
    model in the form given in Skogestad second edition p 119 equations
    4.3 and 4.4
        Severity: Minor
        Found in robustcontrol/utils.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 tf2ss has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
        Open

        def tf2ss(H):
    """
    Converts a mimotf object to the controllable canonical form state space
    representation. This method and the examples were obtained from course work
    notes available at
        Severity: Minor
        Found in robustcontrol/utils.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 sv_dir has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
        Open

        def sv_dir(G, table=False):
    """
    Returns the input and output singular vectors associated with the
    minimum and maximum singular values.
        Severity: Minor
        Found in robustcontrol/utils.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 BoundST has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
        Open

        def BoundST(G, poles, zeros, deadtime=None):
    """
    This function will calculate the minimum peak values of S and T if the
    system has zeros and poles in the input or output. For standard conditions
    Equation 6.8 (p224) is applied. Equation 6.16 (p226) is used when deadtime
        Severity: Minor
        Found in robustcontrol/utils.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 __init__ has 7 arguments (exceeds 4 allowed). Consider refactoring.
        Open

            def __init__(self, numerator, denominator=1, deadtime=0, name='',
        Severity: Major
        Found in robustcontrol/utils.py - About 50 mins to fix

          Function pole_zero_directions has 7 arguments (exceeds 4 allowed). Consider refactoring.
          Open

          def pole_zero_directions(G, vec, dir_type, display_type='a', e=1E-8, z_tol=1E-4, p_tol=1E-4):
          Severity: Major
          Found in robustcontrol/utils.py - About 50 mins to fix

            Function tf_step has 7 arguments (exceeds 4 allowed). Consider refactoring.
            Open

            def tf_step(G, t_end=10, initial_val=0, points=1000,
            Severity: Major
            Found in robustcontrol/utils.py - About 50 mins to fix

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

              def scaling(G_hat, e, u, input_type='symbolic', Gd_hat=None, d=None):
              Severity: Minor
              Found in robustcontrol/utils.py - About 45 mins to fix

                Function zero_directions_ss has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
                Open

                def zero_directions_ss(A, B, C, D):
    """
    This function calculates the zeros with input and output directions from
    a state space representation using the method outlined on pg. 140
                Severity: Minor
                Found in robustcontrol/utils.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

                Avoid deeply nested control flow statements.
                Open

                                    if (y1[0, 0] > constraint) or bconst:
                        y1[0, 0] = constraint
                        # once constraint the system is oversaturated
                        bconst = True
                        # TODO : incorrect, find the correct switch condition
                Severity: Major
                Found in robustcontrol/utils.py - About 45 mins to fix

                  Function step has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
                  Open

                      def step(self, u_input, t_start=0, t_end=100, points=1000):
        """
        Calculate the time domian step response of a mimotf object.
        
        Parameters:
                  Severity: Minor
                  Found in robustcontrol/utils.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 minors has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
                  Open

                  def minors(G, order):
    """
    Returns the order minors of a MIMO tf G.
    """
    retlist = []
                  Severity: Minor
                  Found in robustcontrol/utils.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 zeros has 5 arguments (exceeds 4 allowed). Consider refactoring.
                  Open

                  def zeros(G=None, A=None, B=None, C=None, D=None):
                  Severity: Minor
                  Found in robustcontrol/utils.py - About 35 mins to fix

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

                    def kalman_controllable(A, B, C, P=None, RP=None):
                    Severity: Minor
                    Found in robustcontrol/utils.py - About 35 mins to fix

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

                      def kalman_observable(A, B, C, Q=None, RQ=None):
                      Severity: Minor
                      Found in robustcontrol/utils.py - About 35 mins to fix

                        Function polylatex has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                        Open

                        def polylatex(coefficients, variable='s'):
    """Return latex representation of a polynomial

    :param coefficients: iterable of coefficients in descending order
    :param variable: string containing variable to use
                        Severity: Minor
                        Found in robustcontrol/utils.py - About 35 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

                        Avoid too many return statements within this function.
                        Open

                                        return G_scaled, Gd_scaled
                        Severity: Major
                        Found in robustcontrol/utils.py - About 30 mins to fix

                          Avoid too many return statements within this function.
                          Open

                                          return G_scaled[0, 0], Gd_scaled[0, 0]
                          Severity: Major
                          Found in robustcontrol/utils.py - About 30 mins to fix

                            Avoid too many return statements within this function.
                            Open

                                            return G_scaled[0, 0]
                            Severity: Major
                            Found in robustcontrol/utils.py - About 30 mins to fix

                              Avoid too many return statements within this function.
                              Open

                                              return G_scaled
                              Severity: Major
                              Found in robustcontrol/utils.py - About 30 mins to fix

                                Function lcm_of_all_minors has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                                Open

                                def lcm_of_all_minors(G):
    """
    Returns the lowest common multiple of all minors of G
    """
    Nrows, Ncols = G.shape
                                Severity: Minor
                                Found in robustcontrol/utils.py - About 25 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

                                TODO found
                                Open

                                                        # TODO : incorrect, find the correct switch condition
                                Severity: Minor
                                Found in robustcontrol/utils.py by fixme

                                TODO found
                                Open

                                    # TODO: calculate time response
                                Severity: Minor
                                Found in robustcontrol/utils.py by fixme

                                TODO found
                                Open

                                        # TODO: poly1d should be replaced by np.polynomial.Polynomial
                                Severity: Minor
                                Found in robustcontrol/utils.py by fixme

                                TODO found
                                Open

                                # TODO: Concatenate tf objects into MIMO structure
                                Severity: Minor
                                Found in robustcontrol/utils.py by fixme

                                TODO found
                                Open

                                        # TODO: Check if there are any cases where we need the symbolic method:
                                Severity: Minor
                                Found in robustcontrol/utils.py by fixme

                                TODO found
                                Open

                                            # TODO: calculate intercept of step and constraint line
                                Severity: Minor
                                Found in robustcontrol/utils.py by fixme

                                TODO found
                                Open

                                    # TODO create a beter function to accept parameters and
                                Severity: Minor
                                Found in robustcontrol/utils.py by fixme

                                TODO found
                                Open

                                    TODO: Add any other relevant values to solve for, for example, if coprime
                                Severity: Minor
                                Found in robustcontrol/utils.py by fixme

                                Line too long (80 > 79 characters)
                                Open

                                        tspan:      The time values corresponding with the response data points.
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Limit all lines to a maximum of 79 characters.

                                There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                                Unexpected spaces around keyword / parameter equals
                                Open

                                                    G_stepdata[i][j] = tf_step(self[i, j], t_end = t_end)[1]
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Don't use spaces around the '=' sign in function arguments.

                                Don't use spaces around the '=' sign when used to indicate a
keyword argument or a default parameter value, except when
using a type annotation.

Okay: def complex(real, imag=0.0):
Okay: return magic(r=real, i=imag)
Okay: boolean(a == b)
Okay: boolean(a != b)
Okay: boolean(a <= b)
Okay: boolean(a >= b)
Okay: def foo(arg: int = 42):
Okay: async def foo(arg: int = 42):

E251: def complex(real, imag = 0.0):
E251: return magic(r = real, i = imag)
E252: def complex(real, image: float=0.0):

                                Blank line contains whitespace
                                Open
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Trailing whitespace is superfluous.

                                The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                                Trailing whitespace
                                Open

                                    def add_deadtime(self, θ):
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Trailing whitespace is superfluous.

                                The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                                Block comment should start with '# '
                                Open

                                    #Finds the approximate lowest common multiple of
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Separate inline comments by at least two spaces.

                                An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                                Line too long (89 > 79 characters)
                                Open

                                        return signal.lsim(signal.lti(self.numerator, self.denominator), *args, **kwargs)
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Limit all lines to a maximum of 79 characters.

                                There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                                Blank line contains whitespace
                                Open
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Trailing whitespace is superfluous.

                                The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                                Missing whitespace around operator
                                Open

                                    if sense=='max':
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Surround operators with a single space on either side.

                                - Always surround these binary operators with a single space on
  either side: assignment (=), augmented assignment (+=, -= etc.),
  comparisons (==, <, >, !=, <=, >=, in, not in, is, is not),
  Booleans (and, or, not).

- If operators with different priorities are used, consider adding
  whitespace around the operators with the lowest priorities.

Okay: i = i + 1
Okay: submitted += 1
Okay: x = x * 2 - 1
Okay: hypot2 = x * x + y * y
Okay: c = (a + b) * (a - b)
Okay: foo(bar, key='word', *args, **kwargs)
Okay: alpha[:-i]

E225: i=i+1
E225: submitted +=1
E225: x = x /2 - 1
E225: z = x **y
E225: z = 1and 1
E226: c = (a+b) * (a-b)
E226: hypot2 = x*x + y*y
E227: c = a|b
E228: msg = fmt%(errno, errmsg)

                                Missing whitespace after ','
                                Open

                                        if not (isinstance(G,tf)  or isinstance(G,mimotf)):
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Each comma, semicolon or colon should be followed by whitespace.

                                Okay: [a, b]
Okay: (3,)
Okay: a[1:4]
Okay: a[:4]
Okay: a[1:]
Okay: a[1:4:2]
E231: ['a','b']
E231: foo(bar,baz)
E231: [{'a':'b'}]

                                Missing whitespace after ','
                                Open

                                        if not (isinstance(G,tf) or isinstance(G,mimotf)):
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Each comma, semicolon or colon should be followed by whitespace.

                                Okay: [a, b]
Okay: (3,)
Okay: a[1:4]
Okay: a[:4]
Okay: a[1:]
Okay: a[1:4:2]
E231: ['a','b']
E231: foo(bar,baz)
E231: [{'a':'b'}]

                                Line too long (80 > 79 characters)
                                Open

                                        Acceptable tolerance for pole validation. Let p_tol be small (optional).
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Limit all lines to a maximum of 79 characters.

                                There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                                Missing whitespace after ','
                                Open

                                            eigvals_in_dir.append([eigvals_in[i], zeros_in[-B.shape[1]:,i]])
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Each comma, semicolon or colon should be followed by whitespace.

                                Okay: [a, b]
Okay: (3,)
Okay: a[1:4]
Okay: a[:4]
Okay: a[1:]
Okay: a[1:4:2]
E231: ['a','b']
E231: foo(bar,baz)
E231: [{'a':'b'}]

                                Unexpected spaces around keyword / parameter equals
                                Open

                                    eigvals_in_dir.sort(key = lambda x: abs(x[0]))
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Don't use spaces around the '=' sign in function arguments.

                                Don't use spaces around the '=' sign when used to indicate a
keyword argument or a default parameter value, except when
using a type annotation.

Okay: def complex(real, imag=0.0):
Okay: return magic(r=real, i=imag)
Okay: boolean(a == b)
Okay: boolean(a != b)
Okay: boolean(a <= b)
Okay: boolean(a >= b)
Okay: def foo(arg: int = 42):
Okay: async def foo(arg: int = 42):

E251: def complex(real, imag = 0.0):
E251: return magic(r = real, i = imag)
E252: def complex(real, image: float=0.0):

                                Unexpected spaces around keyword / parameter equals
                                Open

                                    eigvals_out_dir.sort(key = lambda x: abs(x[0]))
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Don't use spaces around the '=' sign in function arguments.

                                Don't use spaces around the '=' sign when used to indicate a
keyword argument or a default parameter value, except when
using a type annotation.

Okay: def complex(real, imag=0.0):
Okay: return magic(r=real, i=imag)
Okay: boolean(a == b)
Okay: boolean(a != b)
Okay: boolean(a <= b)
Okay: boolean(a >= b)
Okay: def foo(arg: int = 42):
Okay: async def foo(arg: int = 42):

E251: def complex(real, imag = 0.0):
E251: return magic(r = real, i = imag)
E252: def complex(real, image: float=0.0):

                                Blank line contains whitespace
                                Open
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Trailing whitespace is superfluous.

                                The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                                Blank line contains whitespace
                                Open
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Trailing whitespace is superfluous.

                                The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                                Expected 2 blank lines, found 1
                                Open

                                def multi_polylcm(P):
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Separate top-level function and class definitions with two blank lines.

                                Method definitions inside a class are separated by a single blank
line.

Extra blank lines may be used (sparingly) to separate groups of
related functions.  Blank lines may be omitted between a bunch of
related one-liners (e.g. a set of dummy implementations).

Use blank lines in functions, sparingly, to indicate logical
sections.

Okay: def a():\n    pass\n\n\ndef b():\n    pass
Okay: def a():\n    pass\n\n\nasync def b():\n    pass
Okay: def a():\n    pass\n\n\n# Foo\n# Bar\n\ndef b():\n    pass
Okay: default = 1\nfoo = 1
Okay: classify = 1\nfoo = 1

E301: class Foo:\n    b = 0\n    def bar():\n        pass
E302: def a():\n    pass\n\ndef b(n):\n    pass
E302: def a():\n    pass\n\nasync def b(n):\n    pass
E303: def a():\n    pass\n\n\n\ndef b(n):\n    pass
E303: def a():\n\n\n\n    pass
E304: @decorator\n\ndef a():\n    pass
E305: def a():\n    pass\na()
E306: def a():\n    def b():\n        pass\n    def c():\n        pass

                                Expected 2 blank lines, found 1
                                Open

                                def arrayfun(f, A):
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Separate top-level function and class definitions with two blank lines.

                                Method definitions inside a class are separated by a single blank
line.

Extra blank lines may be used (sparingly) to separate groups of
related functions.  Blank lines may be omitted between a bunch of
related one-liners (e.g. a set of dummy implementations).

Use blank lines in functions, sparingly, to indicate logical
sections.

Okay: def a():\n    pass\n\n\ndef b():\n    pass
Okay: def a():\n    pass\n\n\nasync def b():\n    pass
Okay: def a():\n    pass\n\n\n# Foo\n# Bar\n\ndef b():\n    pass
Okay: default = 1\nfoo = 1
Okay: classify = 1\nfoo = 1

E301: class Foo:\n    b = 0\n    def bar():\n        pass
E302: def a():\n    pass\n\ndef b(n):\n    pass
E302: def a():\n    pass\n\nasync def b(n):\n    pass
E303: def a():\n    pass\n\n\n\ndef b(n):\n    pass
E303: def a():\n\n\n\n    pass
E304: @decorator\n\ndef a():\n    pass
E305: def a():\n    pass\na()
E306: def a():\n    def b():\n        pass\n    def c():\n        pass

                                Blank line contains whitespace
                                Open
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Trailing whitespace is superfluous.

                                The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                                Missing whitespace after ','
                                Open

                                            elif (isinstance(G_slice,mimotf)) and (G_slice.shape[0] == G_slice.shape[1]):
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Each comma, semicolon or colon should be followed by whitespace.

                                Okay: [a, b]
Okay: (3,)
Okay: a[1:4]
Okay: a[:4]
Okay: a[1:]
Okay: a[1:4:2]
E231: ['a','b']
E231: foo(bar,baz)
E231: [{'a':'b'}]

                                Line too long (93 > 79 characters)
                                Open

                                def pole_zero_directions(G, vec, dir_type, display_type='a', e=1E-8, z_tol=1E-4, p_tol=1E-4):
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Limit all lines to a maximum of 79 characters.

                                There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                                Block comment should start with '# '
                                Open

                                    #Similar to the input vector
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Separate inline comments by at least two spaces.

                                An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                                Invalid escape sequence '\s'
                                Open

                                        :math:`\sigma` (G) :math:`\sigma` (G :math:`^{-1}` yd)
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Invalid escape sequences are deprecated in Python 3.6.

                                Okay: regex = r'\.png$'
W605: regex = '\.png$'

                                Line too long (91 > 79 characters)
                                Open

                                        G_stepdata = [[0 for i in range(self.shape[0])], [0 for i in range(self.shape[1])]]
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Limit all lines to a maximum of 79 characters.

                                There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                                Trailing whitespace
                                Open

                                        θ: sympy or numpy matrix of dead time
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Trailing whitespace is superfluous.

                                The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                                Block comment should start with '# '
                                Open

                                    #Removes roots by index, returns number of roots
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Separate inline comments by at least two spaces.

                                An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                                Missing whitespace after ','
                                Open

                                    if isinstance(A,tf) or isinstance(A,mimotf):
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Each comma, semicolon or colon should be followed by whitespace.

                                Okay: [a, b]
Okay: (3,)
Okay: a[1:4]
Okay: a[:4]
Okay: a[1:]
Okay: a[1:4:2]
E231: ['a','b']
E231: foo(bar,baz)
E231: [{'a':'b'}]

                                Missing whitespace around operator
                                Open

                                    if sense=='min':
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Surround operators with a single space on either side.

                                - Always surround these binary operators with a single space on
  either side: assignment (=), augmented assignment (+=, -= etc.),
  comparisons (==, <, >, !=, <=, >=, in, not in, is, is not),
  Booleans (and, or, not).

- If operators with different priorities are used, consider adding
  whitespace around the operators with the lowest priorities.

Okay: i = i + 1
Okay: submitted += 1
Okay: x = x * 2 - 1
Okay: hypot2 = x * x + y * y
Okay: c = (a + b) * (a - b)
Okay: foo(bar, key='word', *args, **kwargs)
Okay: alpha[:-i]

E225: i=i+1
E225: submitted +=1
E225: x = x /2 - 1
E225: z = x **y
E225: z = 1and 1
E226: c = (a+b) * (a-b)
E226: hypot2 = x*x + y*y
E227: c = a|b
E228: msg = fmt%(errno, errmsg)

                                Expected 2 blank lines, found 1
                                Open

                                def state_observability(A, C, tol=1e-6):
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Separate top-level function and class definitions with two blank lines.

                                Method definitions inside a class are separated by a single blank
line.

Extra blank lines may be used (sparingly) to separate groups of
related functions.  Blank lines may be omitted between a bunch of
related one-liners (e.g. a set of dummy implementations).

Use blank lines in functions, sparingly, to indicate logical
sections.

Okay: def a():\n    pass\n\n\ndef b():\n    pass
Okay: def a():\n    pass\n\n\nasync def b():\n    pass
Okay: def a():\n    pass\n\n\n# Foo\n# Bar\n\ndef b():\n    pass
Okay: default = 1\nfoo = 1
Okay: classify = 1\nfoo = 1

E301: class Foo:\n    b = 0\n    def bar():\n        pass
E302: def a():\n    pass\n\ndef b(n):\n    pass
E302: def a():\n    pass\n\nasync def b(n):\n    pass
E303: def a():\n    pass\n\n\n\ndef b(n):\n    pass
E303: def a():\n\n\n\n    pass
E304: @decorator\n\ndef a():\n    pass
E305: def a():\n    pass\na()
E306: def a():\n    def b():\n        pass\n    def c():\n        pass

                                Block comment should start with '# '
                                Open

                                    #The length of the vector is the same as the number of rows
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Separate inline comments by at least two spaces.

                                An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                                Expected 2 blank lines, found 1
                                Open

                                def astf(maybetf):
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Separate top-level function and class definitions with two blank lines.

                                Method definitions inside a class are separated by a single blank
line.

Extra blank lines may be used (sparingly) to separate groups of
related functions.  Blank lines may be omitted between a bunch of
related one-liners (e.g. a set of dummy implementations).

Use blank lines in functions, sparingly, to indicate logical
sections.

Okay: def a():\n    pass\n\n\ndef b():\n    pass
Okay: def a():\n    pass\n\n\nasync def b():\n    pass
Okay: def a():\n    pass\n\n\n# Foo\n# Bar\n\ndef b():\n    pass
Okay: default = 1\nfoo = 1
Okay: classify = 1\nfoo = 1

E301: class Foo:\n    b = 0\n    def bar():\n        pass
E302: def a():\n    pass\n\ndef b(n):\n    pass
E302: def a():\n    pass\n\nasync def b(n):\n    pass
E303: def a():\n    pass\n\n\n\ndef b(n):\n    pass
E303: def a():\n\n\n\n    pass
E304: @decorator\n\ndef a():\n    pass
E305: def a():\n    pass\na()
E306: def a():\n    def b():\n        pass\n    def c():\n        pass

                                Trailing whitespace
                                Open

                                                    The values can be given as a 1D list or 1D numpy.array
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Trailing whitespace is superfluous.

                                The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                                Missing whitespace after ','
                                Open

                                    if isinstance(A,tf) or isinstance(A,mimotf):
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Each comma, semicolon or colon should be followed by whitespace.

                                Okay: [a, b]
Okay: (3,)
Okay: a[1:4]
Okay: a[:4]
Okay: a[1:]
Okay: a[1:4:2]
E231: ['a','b']
E231: foo(bar,baz)
E231: [{'a':'b'}]

                                Blank line contains whitespace
                                Open
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Trailing whitespace is superfluous.

                                The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                                Blank line contains whitespace
                                Open
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Trailing whitespace is superfluous.

                                The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                                Blank line contains whitespace
                                Open
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Trailing whitespace is superfluous.

                                The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                                Expected 2 blank lines after class or function definition, found 0
                                Open

                                """
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Separate top-level function and class definitions with two blank lines.

                                Method definitions inside a class are separated by a single blank
line.

Extra blank lines may be used (sparingly) to separate groups of
related functions.  Blank lines may be omitted between a bunch of
related one-liners (e.g. a set of dummy implementations).

Use blank lines in functions, sparingly, to indicate logical
sections.

Okay: def a():\n    pass\n\n\ndef b():\n    pass
Okay: def a():\n    pass\n\n\nasync def b():\n    pass
Okay: def a():\n    pass\n\n\n# Foo\n# Bar\n\ndef b():\n    pass
Okay: default = 1\nfoo = 1
Okay: classify = 1\nfoo = 1

E301: class Foo:\n    b = 0\n    def bar():\n        pass
E302: def a():\n    pass\n\ndef b(n):\n    pass
E302: def a():\n    pass\n\nasync def b(n):\n    pass
E303: def a():\n    pass\n\n\n\ndef b(n):\n    pass
E303: def a():\n\n\n\n    pass
E304: @decorator\n\ndef a():\n    pass
E305: def a():\n    pass\na()
E306: def a():\n    def b():\n        pass\n    def c():\n        pass

                                Block comment should start with '# '
                                Open

                                    #that the input and output directions get matched to the correct zero
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Separate inline comments by at least two spaces.

                                An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                                Block comment should start with '# '
                                Open

                                    #value
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Separate inline comments by at least two spaces.

                                An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                                Line too long (91 > 79 characters)
                                Open

                                        k = self.numerator[self.numerator.order] / self.denominator[self.denominator.order]
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Limit all lines to a maximum of 79 characters.

                                There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                                Blank line contains whitespace
                                Open
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Trailing whitespace is superfluous.

                                The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                                Line too long (84 > 79 characters)
                                Open

                                        Adds first order pade deadtime approx to transfer functions within a mimotf.
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Limit all lines to a maximum of 79 characters.

                                There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                                Block comment should start with '# '
                                Open

                                    #that have been removed
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Separate inline comments by at least two spaces.

                                An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                                Expected 2 blank lines, found 1
                                Open

                                def polygcd(a, b):
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Separate top-level function and class definitions with two blank lines.

                                Method definitions inside a class are separated by a single blank
line.

Extra blank lines may be used (sparingly) to separate groups of
related functions.  Blank lines may be omitted between a bunch of
related one-liners (e.g. a set of dummy implementations).

Use blank lines in functions, sparingly, to indicate logical
sections.

Okay: def a():\n    pass\n\n\ndef b():\n    pass
Okay: def a():\n    pass\n\n\nasync def b():\n    pass
Okay: def a():\n    pass\n\n\n# Foo\n# Bar\n\ndef b():\n    pass
Okay: default = 1\nfoo = 1
Okay: classify = 1\nfoo = 1

E301: class Foo:\n    b = 0\n    def bar():\n        pass
E302: def a():\n    pass\n\ndef b(n):\n    pass
E302: def a():\n    pass\n\nasync def b(n):\n    pass
E303: def a():\n    pass\n\n\n\ndef b(n):\n    pass
E303: def a():\n\n\n\n    pass
E304: @decorator\n\ndef a():\n    pass
E305: def a():\n    pass\na()
E306: def a():\n    def b():\n        pass\n    def c():\n        pass

                                Invalid escape sequence '\s'
                                Open

                                    :math:`\sigma` (A) : array
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Invalid escape sequences are deprecated in Python 3.6.

                                Okay: regex = r'\.png$'
W605: regex = '\.png$'

                                Blank line contains whitespace
                                Open
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Trailing whitespace is superfluous.

                                The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                                Block comment should start with '# '
                                Open

                                    #Calculate controllability matrix if necessary
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Separate inline comments by at least two spaces.

                                An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                                Missing whitespace after ','
                                Open

                                        if not (isinstance(G,tf) or isinstance(G,mimotf)):
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Each comma, semicolon or colon should be followed by whitespace.

                                Okay: [a, b]
Okay: (3,)
Okay: a[1:4]
Okay: a[:4]
Okay: a[1:]
Okay: a[1:4:2]
E231: ['a','b']
E231: foo(bar,baz)
E231: [{'a':'b'}]

                                Blank line contains whitespace
                                Open
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Trailing whitespace is superfluous.

                                The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                                Blank line contains whitespace
                                Open
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Trailing whitespace is superfluous.

                                The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                                Multiple spaces after keyword
                                Open

                                        return  Exception("Matrix dimensions incompatible")
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Avoid extraneous whitespace around keywords.

                                Okay: True and False
E271: True and  False
E272: True  and False
E273: True and\tFalse
E274: True\tand False

                                Line too long (85 > 79 characters)
                                Open

                                    >>> G = mimotf([[tf([1.], [1., 1.], deadtime=1), tf([1.], [1., 2.], deadtime=5)],
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Limit all lines to a maximum of 79 characters.

                                There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                                Blank line contains whitespace
                                Open
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Trailing whitespace is superfluous.

                                The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                                Blank line contains whitespace
                                Open
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Trailing whitespace is superfluous.

                                The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                                Blank line contains whitespace
                                Open
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Trailing whitespace is superfluous.

                                The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                                Line too long (89 > 79 characters)
                                Open

                                            elif (isinstance(G_slice,mimotf)) and (G_slice.shape[0] == G_slice.shape[1]):
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Limit all lines to a maximum of 79 characters.

                                There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                                Block comment should start with '# '
                                Open

                                    #in the B matrix.
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Separate inline comments by at least two spaces.

                                An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                                Line too long (81 > 79 characters)
                                Open

                                        return signal.lti(self.numerator, self.denominator).step(*args, **kwargs)
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Limit all lines to a maximum of 79 characters.

                                There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                                Trailing whitespace
                                Open

                                        G_response: A list of arrays, with a length equal to the amount of
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Trailing whitespace is superfluous.

                                The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                                Block comment should start with '# '
                                Open

                                    #two polynomials
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Separate inline comments by at least two spaces.

                                An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                                Trailing whitespace
                                Open

                                    gain.
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Trailing whitespace is superfluous.

                                The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                                Blank line contains whitespace
                                Open
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Trailing whitespace is superfluous.

                                The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                                Blank line contains whitespace
                                Open
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Trailing whitespace is superfluous.

                                The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                                Missing whitespace after ','
                                Open

                                    if isinstance(A,mimotf):
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Each comma, semicolon or colon should be followed by whitespace.

                                Okay: [a, b]
Okay: (3,)
Okay: a[1:4]
Okay: a[:4]
Okay: a[1:]
Okay: a[1:4:2]
E231: ['a','b']
E231: foo(bar,baz)
E231: [{'a':'b'}]

                                Inline comment should start with '# '
                                Open

                                    else:    #no roots in common
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Separate inline comments by at least two spaces.

                                An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                                Blank line contains whitespace
                                Open
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Trailing whitespace is superfluous.

                                The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                                Missing whitespace after ','
                                Open

                                    elif isinstance(A,tf):
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Each comma, semicolon or colon should be followed by whitespace.

                                Okay: [a, b]
Okay: (3,)
Okay: a[1:4]
Okay: a[:4]
Okay: a[1:]
Okay: a[1:4:2]
E231: ['a','b']
E231: foo(bar,baz)
E231: [{'a':'b'}]

                                Missing whitespace after ','
                                Open

                                            if isinstance(G_slice,tf):
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Each comma, semicolon or colon should be followed by whitespace.

                                Okay: [a, b]
Okay: (3,)
Okay: a[1:4]
Okay: a[:4]
Okay: a[1:]
Okay: a[1:4:2]
E231: ['a','b']
E231: foo(bar,baz)
E231: [{'a':'b'}]

                                Expected 2 blank lines after class or function definition, found 1
                                Open

                                if __name__ == '__main__':
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Separate top-level function and class definitions with two blank lines.

                                Method definitions inside a class are separated by a single blank
line.

Extra blank lines may be used (sparingly) to separate groups of
related functions.  Blank lines may be omitted between a bunch of
related one-liners (e.g. a set of dummy implementations).

Use blank lines in functions, sparingly, to indicate logical
sections.

Okay: def a():\n    pass\n\n\ndef b():\n    pass
Okay: def a():\n    pass\n\n\nasync def b():\n    pass
Okay: def a():\n    pass\n\n\n# Foo\n# Bar\n\ndef b():\n    pass
Okay: default = 1\nfoo = 1
Okay: classify = 1\nfoo = 1

E301: class Foo:\n    b = 0\n    def bar():\n        pass
E302: def a():\n    pass\n\ndef b(n):\n    pass
E302: def a():\n    pass\n\nasync def b(n):\n    pass
E303: def a():\n    pass\n\n\n\ndef b(n):\n    pass
E303: def a():\n\n\n\n    pass
E304: @decorator\n\ndef a():\n    pass
E305: def a():\n    pass\na()
E306: def a():\n    def b():\n        pass\n    def c():\n        pass

                                Block comment should start with '# '
                                Open

                                    #Returns the indices of common (approximately equal) roots
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Separate inline comments by at least two spaces.

                                An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                                Block comment should start with '# '
                                Open

                                    #of two polynomials
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Separate inline comments by at least two spaces.

                                An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                                Inline comment should start with '# '
                                Open

                                    if cancelled > 0:    #some roots in common
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Separate inline comments by at least two spaces.

                                An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                                Blank line contains whitespace
                                Open
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Trailing whitespace is superfluous.

                                The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                                Line too long (96 > 79 characters)
                                Open

                                                      Test whether terms were possibly cancelled out in determinant calculation.
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Limit all lines to a maximum of 79 characters.

                                There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                                Blank line contains whitespace
                                Open
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Trailing whitespace is superfluous.

                                The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                                Ambiguous variable name 'i'
                                Open

                                def RGAnumber(G, I):
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Never use the characters 'l', 'O', or 'I' as variable names.

                                In some fonts, these characters are indistinguishable from the
numerals one and zero. When tempted to use 'l', use 'L' instead.

Okay: L = 0
Okay: o = 123
Okay: i = 42
E741: l = 0
E741: O = 123
E741: I = 42

Variables can be bound in several other contexts, including class
and function definitions, 'global' and 'nonlocal' statements,
exception handlers, and 'with' and 'for' statements.
In addition, we have a special handling for function parameters.

Okay: except AttributeError as o:
Okay: with lock as L:
Okay: foo(l=12)
Okay: for a in foo(l=12):
E741: except AttributeError as O:
E741: with lock as l:
E741: global I
E741: nonlocal l
E741: def foo(l):
E741: def foo(l=12):
E741: l = foo(l=12)
E741: for l in range(10):
E742: class I(object):
E743: def l(x):

                                Missing whitespace after ','
                                Open

                                        if not (isinstance(G,tf)  or isinstance(G,mimotf)):
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Each comma, semicolon or colon should be followed by whitespace.

                                Okay: [a, b]
Okay: (3,)
Okay: a[1:4]
Okay: a[:4]
Okay: a[1:]
Okay: a[1:4:2]
E231: ['a','b']
E231: foo(bar,baz)
E231: [{'a':'b'}]

                                Expected 2 blank lines, found 1
                                Open

                                def zero_directions_ss(A, B, C, D):
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Separate top-level function and class definitions with two blank lines.

                                Method definitions inside a class are separated by a single blank
line.

Extra blank lines may be used (sparingly) to separate groups of
related functions.  Blank lines may be omitted between a bunch of
related one-liners (e.g. a set of dummy implementations).

Use blank lines in functions, sparingly, to indicate logical
sections.

Okay: def a():\n    pass\n\n\ndef b():\n    pass
Okay: def a():\n    pass\n\n\nasync def b():\n    pass
Okay: def a():\n    pass\n\n\n# Foo\n# Bar\n\ndef b():\n    pass
Okay: default = 1\nfoo = 1
Okay: classify = 1\nfoo = 1

E301: class Foo:\n    b = 0\n    def bar():\n        pass
E302: def a():\n    pass\n\ndef b(n):\n    pass
E302: def a():\n    pass\n\nasync def b(n):\n    pass
E303: def a():\n    pass\n\n\n\ndef b(n):\n    pass
E303: def a():\n\n\n\n    pass
E304: @decorator\n\ndef a():\n    pass
E305: def a():\n    pass\na()
E306: def a():\n    def b():\n        pass\n    def c():\n        pass

                                Missing whitespace after ','
                                Open

                                            eigvals_out_dir.append([eigvals_out[i], zeros_out[-C.shape[0]:,i]])
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Each comma, semicolon or colon should be followed by whitespace.

                                Okay: [a, b]
Okay: (3,)
Okay: a[1:4]
Okay: a[:4]
Okay: a[1:]
Okay: a[1:4:2]
E231: ['a','b']
E231: foo(bar,baz)
E231: [{'a':'b'}]

                                Blank line contains whitespace
                                Open
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Trailing whitespace is superfluous.

                                The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                                Invalid escape sequence '\s'
                                Open

                                        :math:`\sigma` (G) :math:`\sigma` (G :math:`^{-1}` yd)
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Invalid escape sequences are deprecated in Python 3.6.

                                Okay: regex = r'\.png$'
W605: regex = '\.png$'

                                Trailing whitespace
                                Open

                                                    outputs of the transfer function. The arrays contain the
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Trailing whitespace is superfluous.

                                The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                                Blank line contains whitespace
                                Open
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Trailing whitespace is superfluous.

                                The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                                Trailing whitespace
                                Open

                                        Frequency range.
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Trailing whitespace is superfluous.

                                The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                                Unexpected spaces around keyword / parameter equals
                                Open

                                    eigvals_in_dir.sort(key = lambda x: abs(x[0]))
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Don't use spaces around the '=' sign in function arguments.

                                Don't use spaces around the '=' sign when used to indicate a
keyword argument or a default parameter value, except when
using a type annotation.

Okay: def complex(real, imag=0.0):
Okay: return magic(r=real, i=imag)
Okay: boolean(a == b)
Okay: boolean(a != b)
Okay: boolean(a <= b)
Okay: boolean(a >= b)
Okay: def foo(arg: int = 42):
Okay: async def foo(arg: int = 42):

E251: def complex(real, imag = 0.0):
E251: return magic(r = real, i = imag)
E252: def complex(real, image: float=0.0):

                                Expected 2 blank lines, found 1
                                Open

                                def ssr_solve(A, B, C, D):
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Separate top-level function and class definitions with two blank lines.

                                Method definitions inside a class are separated by a single blank
line.

Extra blank lines may be used (sparingly) to separate groups of
related functions.  Blank lines may be omitted between a bunch of
related one-liners (e.g. a set of dummy implementations).

Use blank lines in functions, sparingly, to indicate logical
sections.

Okay: def a():\n    pass\n\n\ndef b():\n    pass
Okay: def a():\n    pass\n\n\nasync def b():\n    pass
Okay: def a():\n    pass\n\n\n# Foo\n# Bar\n\ndef b():\n    pass
Okay: default = 1\nfoo = 1
Okay: classify = 1\nfoo = 1

E301: class Foo:\n    b = 0\n    def bar():\n        pass
E302: def a():\n    pass\n\ndef b(n):\n    pass
E302: def a():\n    pass\n\nasync def b(n):\n    pass
E303: def a():\n    pass\n\n\n\ndef b(n):\n    pass
E303: def a():\n\n\n\n    pass
E304: @decorator\n\ndef a():\n    pass
E305: def a():\n    pass\na()
E306: def a():\n    def b():\n        pass\n    def c():\n        pass

                                Line too long (148 > 79 characters)
                                Open

                                    ValueError: Transfer functions can only be added if their deadtimes are the same. self=tf([0.5], [1.  0.5]), other=tf([1.], [1. 1.], deadtime=2)
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Limit all lines to a maximum of 79 characters.

                                There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                                Blank line contains whitespace
                                Open
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Trailing whitespace is superfluous.

                                The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                                Blank line contains whitespace
                                Open
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Trailing whitespace is superfluous.

                                The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                                Line too long (121 > 79 characters)
                                Open

                                        return mimotf([[self[i, j]*tf(1, 1, θ[i, j]) for j in range(0, self.shape[1])] for i in range(0, self.shape[0])])
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Limit all lines to a maximum of 79 characters.

                                There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                                Line too long (119 > 79 characters)
                                Open

                                    """Converts a mimotf object making use of individual tf objects to a transfer function system in sympy.Matrix form.
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Limit all lines to a maximum of 79 characters.

                                There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                                Trailing whitespace
                                Open

                                    """
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Trailing whitespace is superfluous.

                                The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                                Line too long (136 > 79 characters)
                                Open

                                        return mimotf([[self[i, j]*tf(1 - θ[i, j]/2, 1 + θ[i, j]/2) for j in range(0, self.shape[1])] for i in range(0, self.shape[0])])
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Limit all lines to a maximum of 79 characters.

                                There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                                Expected 2 blank lines, found 1
                                Open

                                def state_observability_matrix(a, c):
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Separate top-level function and class definitions with two blank lines.

                                Method definitions inside a class are separated by a single blank
line.

Extra blank lines may be used (sparingly) to separate groups of
related functions.  Blank lines may be omitted between a bunch of
related one-liners (e.g. a set of dummy implementations).

Use blank lines in functions, sparingly, to indicate logical
sections.

Okay: def a():\n    pass\n\n\ndef b():\n    pass
Okay: def a():\n    pass\n\n\nasync def b():\n    pass
Okay: def a():\n    pass\n\n\n# Foo\n# Bar\n\ndef b():\n    pass
Okay: default = 1\nfoo = 1
Okay: classify = 1\nfoo = 1

E301: class Foo:\n    b = 0\n    def bar():\n        pass
E302: def a():\n    pass\n\ndef b(n):\n    pass
E302: def a():\n    pass\n\nasync def b(n):\n    pass
E303: def a():\n    pass\n\n\n\ndef b(n):\n    pass
E303: def a():\n\n\n\n    pass
E304: @decorator\n\ndef a():\n    pass
E305: def a():\n    pass\na()
E306: def a():\n    def b():\n        pass\n    def c():\n        pass

                                Line too long (80 > 79 characters)
                                Open

                                        Acceptable tolerance for zero validation. Let z_tol be small (optional).
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Limit all lines to a maximum of 79 characters.

                                There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                                Block comment should start with '# '
                                Open

                                    #The eigenvalues are returned in no specific order. Sorting ensures
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Separate inline comments by at least two spaces.

                                An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                                Blank line contains whitespace
                                Open
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Trailing whitespace is superfluous.

                                The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                                Trailing whitespace
                                Open

                                        θ: sympy or numpy matrix of dead time
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Trailing whitespace is superfluous.

                                The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                                Too many blank lines (4)
                                Open

                                def scaling(G_hat, e, u, input_type='symbolic', Gd_hat=None, d=None):
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Separate top-level function and class definitions with two blank lines.

                                Method definitions inside a class are separated by a single blank
line.

Extra blank lines may be used (sparingly) to separate groups of
related functions.  Blank lines may be omitted between a bunch of
related one-liners (e.g. a set of dummy implementations).

Use blank lines in functions, sparingly, to indicate logical
sections.

Okay: def a():\n    pass\n\n\ndef b():\n    pass
Okay: def a():\n    pass\n\n\nasync def b():\n    pass
Okay: def a():\n    pass\n\n\n# Foo\n# Bar\n\ndef b():\n    pass
Okay: default = 1\nfoo = 1
Okay: classify = 1\nfoo = 1

E301: class Foo:\n    b = 0\n    def bar():\n        pass
E302: def a():\n    pass\n\ndef b(n):\n    pass
E302: def a():\n    pass\n\nasync def b(n):\n    pass
E303: def a():\n    pass\n\n\n\ndef b(n):\n    pass
E303: def a():\n\n\n\n    pass
E304: @decorator\n\ndef a():\n    pass
E305: def a():\n    pass\na()
E306: def a():\n    def b():\n        pass\n    def c():\n        pass

                                Blank line contains whitespace
                                Open
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Trailing whitespace is superfluous.

                                The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                                Block comment should start with '# '
                                Open

                                    #The input vector direction is given by u_z as shown in eq. 4.66.
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Separate inline comments by at least two spaces.

                                An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                                Block comment should start with '# '
                                Open

                                    #The length of the vector is the same as the number of columns
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Separate inline comments by at least two spaces.

                                An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                                Block comment should start with '# '
                                Open

                                    #in the C matrix.
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Separate inline comments by at least two spaces.

                                An inline comment is a comment on the same line as a statement.
Inline comments should be separated by at least two spaces from the
statement. They should start with a # and a single space.

Each line of a block comment starts with a # and a single space
(unless it is indented text inside the comment).

Okay: x = x + 1  # Increment x
Okay: x = x + 1    # Increment x
Okay: # Block comment
E261: x = x + 1 # Increment x
E262: x = x + 1  #Increment x
E262: x = x + 1  #  Increment x
E265: #Block comment
E266: ### Block comment

                                Unexpected spaces around keyword / parameter equals
                                Open

                                    eigvals_out_dir.sort(key = lambda x: abs(x[0]))
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Don't use spaces around the '=' sign in function arguments.

                                Don't use spaces around the '=' sign when used to indicate a
keyword argument or a default parameter value, except when
using a type annotation.

Okay: def complex(real, imag=0.0):
Okay: return magic(r=real, i=imag)
Okay: boolean(a == b)
Okay: boolean(a != b)
Okay: boolean(a <= b)
Okay: boolean(a >= b)
Okay: def foo(arg: int = 42):
Okay: async def foo(arg: int = 42):

E251: def complex(real, imag = 0.0):
E251: return magic(r = real, i = imag)
E252: def complex(real, image: float=0.0):

                                Blank line contains whitespace
                                Open
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Trailing whitespace is superfluous.

                                The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                                Blank line contains whitespace
                                Open
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Trailing whitespace is superfluous.

                                The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                                Unexpected spaces around keyword / parameter equals
                                Open

                                                    G_stepdata[i][j] = tf_step(self[i, j], t_end = t_end)[1]
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Don't use spaces around the '=' sign in function arguments.

                                Don't use spaces around the '=' sign when used to indicate a
keyword argument or a default parameter value, except when
using a type annotation.

Okay: def complex(real, imag=0.0):
Okay: return magic(r=real, i=imag)
Okay: boolean(a == b)
Okay: boolean(a != b)
Okay: boolean(a <= b)
Okay: boolean(a >= b)
Okay: def foo(arg: int = 42):
Okay: async def foo(arg: int = 42):

E251: def complex(real, imag = 0.0):
E251: return magic(r = real, i = imag)
E252: def complex(real, image: float=0.0):

                                Trailing whitespace
                                Open

                                    def add_padeapprox_deadtime(self, θ):
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Trailing whitespace is superfluous.

                                The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                                Ambiguous variable name 'i'
                                Open

                                    I = numpy.eye(G.outputs, G.inputs)
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Never use the characters 'l', 'O', or 'I' as variable names.

                                In some fonts, these characters are indistinguishable from the
numerals one and zero. When tempted to use 'l', use 'L' instead.

Okay: L = 0
Okay: o = 123
Okay: i = 42
E741: l = 0
E741: O = 123
E741: I = 42

Variables can be bound in several other contexts, including class
and function definitions, 'global' and 'nonlocal' statements,
exception handlers, and 'with' and 'for' statements.
In addition, we have a special handling for function parameters.

Okay: except AttributeError as o:
Okay: with lock as L:
Okay: foo(l=12)
Okay: for a in foo(l=12):
E741: except AttributeError as O:
E741: with lock as l:
E741: global I
E741: nonlocal l
E741: def foo(l):
E741: def foo(l=12):
E741: l = foo(l=12)
E741: for l in range(10):
E742: class I(object):
E743: def l(x):

                                Trailing whitespace
                                Open

                                    Currently functionality allows for a controller with proportional
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Trailing whitespace is superfluous.

                                The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                                Blank line contains whitespace
                                Open
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Trailing whitespace is superfluous.

                                The warning returned varies on whether the line itself is blank,
for easier filtering for those who want to indent their blank lines.

Okay: spam(1)\n#
W291: spam(1) \n#
W293: class Foo(object):\n    \n    bang = 12

                                Ambiguous variable name 'o'
                                Open

                                    O = state_observability_matrix(a, c)
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Never use the characters 'l', 'O', or 'I' as variable names.

                                In some fonts, these characters are indistinguishable from the
numerals one and zero. When tempted to use 'l', use 'L' instead.

Okay: L = 0
Okay: o = 123
Okay: i = 42
E741: l = 0
E741: O = 123
E741: I = 42

Variables can be bound in several other contexts, including class
and function definitions, 'global' and 'nonlocal' statements,
exception handlers, and 'with' and 'for' statements.
In addition, we have a special handling for function parameters.

Okay: except AttributeError as o:
Okay: with lock as L:
Okay: foo(l=12)
Okay: for a in foo(l=12):
E741: except AttributeError as O:
E741: with lock as l:
E741: global I
E741: nonlocal l
E741: def foo(l):
E741: def foo(l=12):
E741: l = foo(l=12)
E741: for l in range(10):
E742: class I(object):
E743: def l(x):

                                Expected 2 blank lines, found 1
                                Open

                                def is_min_realisation(A, B, C):
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Separate top-level function and class definitions with two blank lines.

                                Method definitions inside a class are separated by a single blank
line.

Extra blank lines may be used (sparingly) to separate groups of
related functions.  Blank lines may be omitted between a bunch of
related one-liners (e.g. a set of dummy implementations).

Use blank lines in functions, sparingly, to indicate logical
sections.

Okay: def a():\n    pass\n\n\ndef b():\n    pass
Okay: def a():\n    pass\n\n\nasync def b():\n    pass
Okay: def a():\n    pass\n\n\n# Foo\n# Bar\n\ndef b():\n    pass
Okay: default = 1\nfoo = 1
Okay: classify = 1\nfoo = 1

E301: class Foo:\n    b = 0\n    def bar():\n        pass
E302: def a():\n    pass\n\ndef b(n):\n    pass
E302: def a():\n    pass\n\nasync def b(n):\n    pass
E303: def a():\n    pass\n\n\n\ndef b(n):\n    pass
E303: def a():\n\n\n\n    pass
E304: @decorator\n\ndef a():\n    pass
E305: def a():\n    pass\na()
E306: def a():\n    def b():\n        pass\n    def c():\n        pass

                                Line too long (87 > 79 characters)
                                Open

                                    Determine poles and zeros of a square mimotf matrix, making use of the determinant.
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Limit all lines to a maximum of 79 characters.

                                There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                                Line too long (101 > 79 characters)
                                Open

                                    This method may fail in special cases. If terms cancel out during calculation of the determinant,
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Limit all lines to a maximum of 79 characters.

                                There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                                Line too long (80 > 79 characters)
                                Open

                                                numer_test = sympy.Poly(sympy.numer(minor_multiply).expand(), s)
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Limit all lines to a maximum of 79 characters.

                                There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.

                                Multiple spaces before keyword
                                Open

                                        if not (isinstance(G,tf)  or isinstance(G,mimotf)):
                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Avoid extraneous whitespace around keywords.

                                Okay: True and False
E271: True and  False
E272: True  and False
E273: True and\tFalse
E274: True\tand False

                                Blank line at end of file
                                Open

                                Severity: Minor
                                Found in robustcontrol/utils.py by pep8

                                Trailing blank lines are superfluous.

                                Okay: spam(1)
W391: spam(1)\n

However the last line should end with a new line (warning W292).

                                There are no issues that match your filters.

                                Category
                                Status