Sign upLogin

alchemyst/Skogestad-Python

View on GitHub
Star

Showing 668 of 668 total issues

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 weight_calc_dec has 5 arguments (exceeds 4 allowed). Consider refactoring.
    Open

    def weight_calc_dec(w_start, w_end, li, weight_i, steps):
    Severity: Minor
    Found in Uncertain_MIMO.py - About 35 mins to fix

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

      def PEAK_MIMO(w_start, w_end, error_poles_direction, wr, deadtime_if=0):
      Severity: Minor
      Found in PEAK_MIMO.py - About 35 mins to fix

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

            def subbode(A, text, crossover, labB, labP):
        Severity: Minor
        Found in robustcontrol/utilsplot.py - About 35 mins to fix

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

          def rule_three_four(G, Gd, R=1.1, perfect=True,
          Severity: Minor
          Found in siso_controllability.py - About 35 mins to fix

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

            def satisfy(wI, G, Gp, params, s):
            Severity: Minor
            Found in robustcontrol/doc_func.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 __init__ has 5 arguments (exceeds 4 allowed). Consider refactoring.
                  Open

                      def __init__(self, name, out_name, in1, in2, add=True):
                  Severity: Minor
                  Found in connect.py - About 35 mins to fix

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

                    def mimo_nyquist_plot(L, w_start=-2, w_end=2, axlim=None, points=1000):
                    Severity: Minor
                    Found in robustcontrol/utilsplot.py - About 35 mins to fix

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

                      def rule3(G, Gd, message=False, w1=-4, w2=2):
                      Severity: Minor
                      Found in robustcontrol/Chapter_05.py - About 35 mins to fix

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

                            def __init__(self, *system):
        N = len(system)

        if N == 1:  # could be either a utils.tf or utils.mimotf object
            sys = system[0]
                        Severity: Minor
                        Found in robustcontrol/InternalDelay.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

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

                        def weight_calc(w_start, w_end, li, weight_i, steps):
    """Calculates a simple third-order weight
    Accommodates situations were the weight increases with frequency
    """
                        Severity: Minor
                        Found in Uncertain_MIMO.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

                        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[0, 0], Gd_scaled[0, 0]
                        Severity: Major
                        Found in robustcontrol/utils.py - About 30 mins to fix

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

                          def Wp(s):
    """
    Give the performance weight matrix.
    """
    Wp = np.matrix([[10, 10], [10, 10]])
                          Severity: Minor
                          Found in P_N_M_matrices.py and 2 other locations - About 30 mins to fix
                          P_N_M_matrices.py on lines 39..46
                          P_N_M_matrices.py on lines 57..62

                          Duplicated Code

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

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

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

                          Tuning

                          This issue has a mass of 32.

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

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

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

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

                          Refactorings

                          Further Reading

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

                                  plt.loglog(w, inv_norm_gd[i], label=('$1/||g_{d%s}||_2$' % (i+1)))
                          Severity: Major
                          Found in robustcontrol/utilsplot.py and 3 other locations - About 30 mins to fix
                          robustcontrol/utilsplot.py on lines 866..867
                          robustcontrol/utilsplot.py on lines 891..891
                          robustcontrol/utilsplot.py on lines 939..939

                          Duplicated Code

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

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

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

                          Tuning

                          This issue has a mass of 32.

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

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

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

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

                          Refactorings

                          Further Reading

                          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

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

                            def Wg(s):
    """
    Give the uncertainty weight matrix.
    This is the weight that is multiplied by the delta matrix and
    goes by different names depending on the form of unstructured uncertainty.
                            Severity: Minor
                            Found in P_N_M_matrices.py and 2 other locations - About 30 mins to fix
                            P_N_M_matrices.py on lines 31..36
                            P_N_M_matrices.py on lines 57..62

                            Duplicated Code

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

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

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

                            Tuning

                            This issue has a mass of 32.

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

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

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

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

                            Refactorings

                            Further Reading

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

                                for i in range(dim):
        plt.loglog(w, condtn_nm_gd[i], label=('$\gamma_{d%s} (G)$' % (i+1)))
                            Severity: Major
                            Found in robustcontrol/utilsplot.py and 3 other locations - About 30 mins to fix
                            robustcontrol/utilsplot.py on lines 878..878
                            robustcontrol/utilsplot.py on lines 891..891
                            robustcontrol/utilsplot.py on lines 939..939

                            Duplicated Code

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

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

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

                            Tuning

                            This issue has a mass of 32.

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

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

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

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

                            Refactorings

                            Further Reading

                            Severity
                            Category
                            Status
                            Source
                            Language