Sign upLogin

pygae/galgebra

View on GitHub
Star
galgebra/lt.py

Summary

Maintainability
F
6 days
Test Coverage

File lt.py has 756 lines of code (exceeds 250 allowed). Consider refactoring.
Open

"""
Multivector Linear Transformation
"""

import inspect
Severity: Major
Found in galgebra/lt.py - About 1 day to fix

    Function Symbolic_Matrix has a Cognitive Complexity of 65 (exceeds 5 allowed). Consider refactoring.
    Open

    def Symbolic_Matrix(root, coords=None, mode='g', f=False, sub=True):
    if sub:
        pos = '_'
    else:
        pos = '__'
    Severity: Minor
    Found in galgebra/lt.py - About 1 day 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 a Cognitive Complexity of 35 (exceeds 5 allowed). Consider refactoring.
    Open

        def __init__(self, *args, ga, f=False, mode='g'):
        """
        __init__(self, *args, ga, **kwargs)

        Note this constructor is overloaded, based on the type of the
    Severity: Minor
    Found in galgebra/lt.py - About 5 hrs to fix

    Cognitive Complexity

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

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

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

    Further reading

    Cyclomatic complexity is too high in function Symbolic_Matrix. (18)
    Open

    def Symbolic_Matrix(root, coords=None, mode='g', f=False, sub=True):
    if sub:
        pos = '_'
    else:
        pos = '__'
    Severity: Minor
    Found in galgebra/lt.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 __init__. (17)
    Open

        def __init__(self, *args, ga, f=False, mode='g'):
        """
        __init__(self, *args, ga, **kwargs)

        Note this constructor is overloaded, based on the type of the
    Severity: Minor
    Found in galgebra/lt.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 __call__ has a Cognitive Complexity of 22 (exceeds 5 allowed). Consider refactoring.
    Open

        def __call__(self, v, obj=False):
        r"""
        Returns the image of the multivector :math:`A` under the linear transformation :math:`L`.

        :math:`{{L}\lp {A} \rp }` is defined by the linearity of :math:`L`, the
    Severity: Minor
    Found in galgebra/lt.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 method _latex. (12)
    Open

        def _latex(self, print_obj):
        if self.nargs <= 1:
            return print_obj._print(self.fvalue)
        expr_lst = Mlt.expand_expr(self.fvalue, self.Ga)
        latex_str = '\\begin{aligned} '
    Severity: Minor
    Found in galgebra/lt.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 _latex has a Cognitive Complexity of 20 (exceeds 5 allowed). Consider refactoring.
    Open

        def _latex(self, print_obj):
        if self.nargs <= 1:
            return print_obj._print(self.fvalue)
        expr_lst = Mlt.expand_expr(self.fvalue, self.Ga)
        latex_str = '\\begin{aligned} '
    Severity: Minor
    Found in galgebra/lt.py - About 2 hrs to fix

    Cognitive Complexity

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

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

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

    Further reading

    Cyclomatic complexity is too high in method __call__. (11)
    Open

        def __call__(self, v, obj=False):
        r"""
        Returns the image of the multivector :math:`A` under the linear transformation :math:`L`.

        :math:`{{L}\lp {A} \rp }` is defined by the linearity of :math:`L`, the
    Severity: Minor
    Found in galgebra/lt.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 expand_expr. (10)
    Open

        @staticmethod
    def expand_expr(expr, ga):
        lst_expr = []
        expr = expand(expr)
        for term in expr.args:
    Severity: Minor
    Found in galgebra/lt.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 __init__. (9)
    Open

        def __init__(self, f, Ga, nargs=None, fct=False):
        #  f is a function, a multivector, a string, or a component expression
        #  self.f is a function or None such as T | a_1 where T and a_1 are vectors
        #  self.fvalue is a component expression such as
        #  T_x*a_1__x+T_y*a_1__y+T_z*a_1__z for a rank 1 tensor in 3 space and all
    Severity: Minor
    Found in galgebra/lt.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 __init__ has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.
    Open

        def __init__(self, f, Ga, nargs=None, fct=False):
        #  f is a function, a multivector, a string, or a component expression
        #  self.f is a function or None such as T | a_1 where T and a_1 are vectors
        #  self.fvalue is a component expression such as
        #  T_x*a_1__x+T_y*a_1__y+T_z*a_1__z for a rank 1 tensor in 3 space and all
    Severity: Minor
    Found in galgebra/lt.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

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

    class Mlt(printer.GaPrintable):
    r"""
    A multilinear transformation (mlt) is a multilinear multivector function of
    a list of vectors (``*args``) :math:`F(v_1,...,v_r)` where for any argument slot
    :math:`j` we have (:math:`a` is a scalar and :math:`u_j` a vector)
    Severity: Minor
    Found in galgebra/lt.py - About 2 hrs to fix

      Function expand_expr has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.
      Open

          def expand_expr(expr, ga):
        lst_expr = []
        expr = expand(expr)
        for term in expr.args:
            coef = S.One
      Severity: Minor
      Found in galgebra/lt.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

      Cyclomatic complexity is too high in method __mul__. (6)
      Open

          def __mul__(self, LT):

        if isinstance(LT, Lt):

            if self.Ga != LT.Ga:
      Severity: Minor
      Found in galgebra/lt.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 __mul__ has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
      Open

          def __mul__(self, LT):

        if isinstance(LT, Lt):

            if self.Ga != LT.Ga:
      Severity: Minor
      Found in galgebra/lt.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

      Avoid deeply nested control flow statements.
      Open

                          if not f:
                        mat[row, col] = Symbol(element, real=True)
                    else:
                        mat[row, col] = Function(element)(*coords)
      Severity: Major
      Found in galgebra/lt.py - About 45 mins to fix

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

            def __call__(self, *args):
        """
        Evaluate the multilinear function for the given vector arguments.
        Note that a sympy scalar is returned, *not* a multilinear function.
        """
        Severity: Minor
        Found in galgebra/lt.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 row <= col:
                        element = root + pos + row_index + col_index
                    else:
                        element = root + pos + col_index + row_index
                    if not f:
        Severity: Major
        Found in galgebra/lt.py - About 45 mins to fix

          Avoid deeply nested control flow statements.
          Open

                              if row <= col:
                        sign = S.One
                        element = root + pos + row_index + col_index
                    else:
                        sign = -S.One
          Severity: Major
          Found in galgebra/lt.py - About 45 mins to fix

            Avoid deeply nested control flow statements.
            Open

                                if not f:
                        mat[row, col] = sign * Symbol(element, real=True)
                    else:
                        mat[row, col] = sign * Function(element)(*coords)
        else:
            Severity: Major
            Found in galgebra/lt.py - About 45 mins to fix

              Avoid deeply nested control flow statements.
              Open

                                  if row == col:
                        sign = S.Zero
                    if not f:
              Severity: Major
              Found in galgebra/lt.py - About 45 mins to fix

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

                    def _sympystr(self, print_obj):

        if self.spinor:
            return 'R = ' + print_obj._print(self.R)
        else:
                Severity: Minor
                Found in galgebra/lt.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 matrix has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
                Open

                    def matrix(self) -> Matrix:
        r"""
        Returns the matrix representation of the linear transformation,
        :math:`L`, defined by :math:`{{L}\lp {{{\eb}}_{i}} \rp } = L_{ij}{{\eb}}_{j}`
        where :math:`L_{ij}` is the matrix representation.
                Severity: Minor
                Found in galgebra/lt.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 not f:
                        mat[row, col] = Symbol(element, real=True)
                    else:
                        mat[row, col] = Function(element)(*coords)
                Severity: Major
                Found in galgebra/lt.py - About 45 mins to fix

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

                  def Symbolic_Matrix(root, coords=None, mode='g', f=False, sub=True):
                  Severity: Minor
                  Found in galgebra/lt.py - About 35 mins to fix

                    Avoid too many return statements within this function.
                    Open

                                return lt_v
                    Severity: Major
                    Found in galgebra/lt.py - About 30 mins to fix

                      Avoid too many return statements within this function.
                      Open

                                  return mv.Mv(lt_v, ga=self.Ga)
                      Severity: Major
                      Found in galgebra/lt.py - About 30 mins to fix

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

                            def adj(self) -> 'Lt':
        r"""
        Returns the adjoint (a linear transformation) of the linear
        transformation, :math:`L`, defined by :math:`a\cdot{{L}\lp {b} \rp } = b\cdot{{\bar{L}}\lp {a} \rp }`
        where :math:`a` and :math:`b` are any two vectors in the tangent space
                        Severity: Minor
                        Found in galgebra/lt.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

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

                            def __init__(self, *args, ga, f=False, mode='g'):
                        Severity: Critical
                        Found in galgebra/lt.py by sonar-python

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

                        See

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

                        def Symbolic_Matrix(root, coords=None, mode='g', f=False, sub=True):
                        Severity: Critical
                        Found in galgebra/lt.py by sonar-python

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

                        See

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

                            def __call__(self, v, obj=False):
                        Severity: Critical
                        Found in galgebra/lt.py by sonar-python

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

                        See

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

                            def __init__(self, f, Ga, nargs=None, fct=False):
                        Severity: Critical
                        Found in galgebra/lt.py by sonar-python

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

                        See

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

                            def _latex(self, print_obj):
                        Severity: Critical
                        Found in galgebra/lt.py by sonar-python

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

                        See

                        Remove this commented out code.
                        Open

                                        # mat_rep = map(list, zip(*mat_rep))  # Transpose list of lists
                        Severity: Major
                        Found in galgebra/lt.py by sonar-python

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

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

                        See

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

                        Remove this commented out code.
                        Open

                                        # self.f = None
                        Severity: Major
                        Found in galgebra/lt.py by sonar-python

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

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

                        See

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

                        Line too long (80 > 79 characters)
                        Open

                            """ Convert matrix representation of linear transformation to dictionary """
                        Severity: Minor
                        Found in galgebra/lt.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 (82 > 79 characters)
                        Open

                            to the coordinate vector (we assume :math:`F` is implicitely a function of the
                        Severity: Minor
                        Found in galgebra/lt.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 (105 > 79 characters)
                        Open

                                        # self.nargs = len(args)  # args isn't defined, which is why we raise NotImplementedError
                        Severity: Minor
                        Found in galgebra/lt.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 (100 > 79 characters)
                        Open

                                        self_add_LT[key] = metric.collect(self_add_LT[key] + LT.lt_dict[key], self.Ga.basis)
                        Severity: Minor
                        Found in galgebra/lt.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 (90 > 79 characters)
                        Open

                                        self_mul_LT[key] = metric.collect(expand(self_mul_LT[key]), self.Ga.basis)
                        Severity: Minor
                        Found in galgebra/lt.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 (81 > 79 characters)
                        Open

                                grad_self = Mlt.remove_slot(grad_self.obj, min_slot, self.nargs, self.Ga)
                        Severity: Minor
                        Found in galgebra/lt.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 (97 > 79 characters)
                        Open

                                Returns the image of the multivector :math:`A` under the linear transformation :math:`L`.
                        Severity: Minor
                        Found in galgebra/lt.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 (91 > 79 characters)
                        Open

                                    raise ValueError('In Lt call Lt and argument refer to different vector spaces')
                        Severity: Minor
                        Found in galgebra/lt.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 (100 > 79 characters)
                        Open

                                        self_add_LT[key] = metric.collect(self_add_LT[key] - LT.lt_dict[key], self.Ga.basis)
                        Severity: Minor
                        Found in galgebra/lt.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 (154 > 79 characters)
                        Open

                                For example if the tensor is :math:`{{T}\lp {a_{1},a_{2}} \rp }` then ``T.pdiff(2)`` is :math:`\nabla_{a_{2}}T`. Since ``T`` is a scalar function,
                        Severity: Minor
                        Found in galgebra/lt.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 (96 > 79 characters)
                        Open

                                    raise ValueError("Attempting subtraction of Lt's from different geometric algebras")
                        Severity: Minor
                        Found in galgebra/lt.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 (88 > 79 characters)
                        Open

                                  F(v_1,...,v_j+u_j,...,v_r) &= F(v_1,...,v_j,...,v_r) + F(v_1,...,u_j,...,v_r).
                        Severity: Minor
                        Found in galgebra/lt.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

                                :math:`L`, defined by :math:`{{\det}\lp {L} \rp }I = {{L}\lp {I} \rp }`.
                        Severity: Minor
                        Found in galgebra/lt.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 (127 > 79 characters)
                        Open

                                            s += pre + print_obj._print(base) + ') = ' + print_obj._print(mv.Mv(self.lt_dict[base], ga=self.Ga)) + '\n'
                        Severity: Minor
                        Found in galgebra/lt.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 (90 > 79 characters)
                        Open

                                    value = self(*self.Ga._mlt_a[:self.nargs]) ^ X(*X.Ga._mlt_a[self.nargs:nargs])
                        Severity: Minor
                        Found in galgebra/lt.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

                            """ Convert dictionary representation of linear transformation to matrix """
                        Severity: Minor
                        Found in galgebra/lt.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 (83 > 79 characters)
                        Open

                            If :math:`F` and :math:`G` are two :class:`Mlt`\ s with :math:`r` and :math:`s`
                        Severity: Minor
                        Found in galgebra/lt.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 (109 > 79 characters)
                        Open

                                transformation, :math:`L`, defined by :math:`a\cdot{{L}\lp {b} \rp } = b\cdot{{\bar{L}}\lp {a} \rp }`
                        Severity: Minor
                        Found in galgebra/lt.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 (86 > 79 characters)
                        Open

                            .. math:: F(v_1,...,v_r;v_{r+1}) = (v_{r+1} \bullet \nabla)F(v_1,...,v_j,...,v_r).
                        Severity: Minor
                        Found in galgebra/lt.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 (89 > 79 characters)
                        Open

                                    "`Mlt.extact_basis_indexes(ga)` is deprecated, use `ga.basis_super_scripts`",
                        Severity: Minor
                        Found in galgebra/lt.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

                                ``slot1`` is the index of the first vector argument and ``slot2`` is the
                        Severity: Minor
                        Found in galgebra/lt.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

                                CD = Mlt((agrad * self.Ga.mv(self.fvalue)).obj, self.Ga, self.nargs + 1)
                        Severity: Minor
                        Found in galgebra/lt.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 (94 > 79 characters)
                        Open

                                raise ValueError('Matrix and Basis dimensions not equal for Matrix = ' + str(mat_rep))
                        Severity: Minor
                        Found in galgebra/lt.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 (81 > 79 characters)
                        Open

                                    raise TypeError("Unsupported argument type {}".format(type(mat_rep)))
                        Severity: Minor
                        Found in galgebra/lt.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 (104 > 79 characters)
                        Open

                                :math:`L`, defined by :math:`{{\operatorname{tr}}\lp {L} \rp }=\nabla_{a}\cdot{{L}\lp {a} \rp }`
                        Severity: Minor
                        Found in galgebra/lt.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 (95 > 79 characters)
                        Open

                            The derivative of a :class:`Mlt` with is defined as the directional derivative with respect
                        Severity: Minor
                        Found in galgebra/lt.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 (105 > 79 characters)
                        Open

                                    for t_index, a_prod in zip(itertools.product(self.Ga.basis_super_scripts, repeat=self.nargs),
                        Severity: Minor
                        Found in galgebra/lt.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 (103 > 79 characters)
                        Open

                                        raise ValueError("Attempting multiplication of Lt's from different geometric algebras")
                        Severity: Minor
                        Found in galgebra/lt.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 (83 > 79 characters)
                        Open

                                    raise ValueError('Lt inverse currently implemented only for spinor!\n')
                        Severity: Minor
                        Found in galgebra/lt.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 (84 > 79 characters)
                        Open

                            a list of vectors (``*args``) :math:`F(v_1,...,v_r)` where for any argument slot
                        Severity: Minor
                        Found in galgebra/lt.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 (93 > 79 characters)
                        Open

                            If F and G are two :class:`Mlt`\ s with the same number of argument slots then the sum is
                        Severity: Minor
                        Found in galgebra/lt.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 (85 > 79 characters)
                        Open

                            .. math:: (F*G)(v_1,...,v_r,...,v_{r+s}) = F(v_1,...,v_r)*G(v_{r+1},...,v_{r+s}),
                        Severity: Minor
                        Found in galgebra/lt.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 (92 > 79 characters)
                        Open

                            geometric derivative of :math:`F` with respect to slot :math:`k` and the inner geometric
                        Severity: Minor
                        Found in galgebra/lt.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 (83 > 79 characters)
                        Open

                                #  self.f is a function or None such as T | a_1 where T and a_1 are vectors
                        Severity: Minor
                        Found in galgebra/lt.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 (85 > 79 characters)
                        Open

                                    mv = mv.subs(list(zip(ga._mlt_pdiffs[islot], ga._mlt_pdiffs[islot - 1])))
                        Severity: Minor
                        Found in galgebra/lt.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 (97 > 79 characters)
                        Open

                                div_grad_self = Mlt.remove_slot(div_grad_self.obj, max_slot - 1, self.nargs - 1, self.Ga)
                        Severity: Minor
                        Found in galgebra/lt.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

                                                               itertools.product(*self.Ga._mlt_pdiffs)):
                        Severity: Minor
                        Found in galgebra/lt.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 (88 > 79 characters)
                        Open

                                    parts.append(print_obj._print(base) + ' &\\mapsto ' + print_obj._print(val))
                        Severity: Minor
                        Found in galgebra/lt.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 (82 > 79 characters)
                        Open

                                        self.mat = Dictionary_to_Matrix(self.lt_dict, self.Ga) * self.Ga.g
                        Severity: Minor
                        Found in galgebra/lt.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 (93 > 79 characters)
                        Open

                            The contraction of a :class:`Mlt` between slots :math:`j` and :math:`k` is defined as the
                        Severity: Minor
                        Found in galgebra/lt.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 (82 > 79 characters)
                        Open

                                    Amat = Symbolic_Matrix(mat_rep, coords=self.Ga.coords, mode=mode, f=f)
                        Severity: Minor
                        Found in galgebra/lt.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 (170 > 79 characters)
                        Open

                                :math:`{{L}\lp {{{\eb}}_{i_{1}}{\wedge}\dots{\wedge}{{\eb}}_{i_{r}}} \rp } = {{L}\lp {{{\eb}}_{i_{1}}} \rp }{\wedge}\dots{\wedge}{{L}\lp {{{\eb}}_{i_{r}}} \rp }`.
                        Severity: Minor
                        Found in galgebra/lt.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 (93 > 79 characters)
                        Open

                                    raise ValueError("Attempting addition of Lt's from different geometric algebras")
                        Severity: Minor
                        Found in galgebra/lt.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 (85 > 79 characters)
                        Open

                                :math:`L`, defined by :math:`{{L}\lp {{{\eb}}_{i}} \rp } = L_{ij}{{\eb}}_{j}`
                        Severity: Minor
                        Found in galgebra/lt.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 (87 > 79 characters)
                        Open

                                # Increment cache of available slots (vector variables) if needed for Mlt class
                        Severity: Minor
                        Found in galgebra/lt.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 (82 > 79 characters)
                        Open

                                #  T_x*a_1__x+T_y*a_1__y+T_z*a_1__z for a rank 1 tensor in 3 space and all
                        Severity: Minor
                        Found in galgebra/lt.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 (85 > 79 characters)
                        Open

                                        raise ValueError('In Spinor input for Lt, S*S.rev() not a scalar!\n')
                        Severity: Minor
                        Found in galgebra/lt.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 (98 > 79 characters)
                        Open

                                return '\\left\\{ \\begin{aligned} ' + ' \\\\ '.join(parts) + ' \\end{aligned} \\right\\}'
                        Severity: Minor
                        Found in galgebra/lt.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

                                    Geometric algebra which is the domain and codomain of this transform
                        Severity: Minor
                        Found in galgebra/lt.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 (100 > 79 characters)
                        Open

                                    if isinstance(f, types.FunctionType):  # Tensor defined by general multi-linear function
                        Severity: Minor
                        Found in galgebra/lt.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 (90 > 79 characters)
                        Open

                                    value = self(*self.Ga._mlt_a[:self.nargs]) | X(*X.Ga._mlt_a[self.nargs:nargs])
                        Severity: Minor
                        Found in galgebra/lt.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.

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

                        def Symbolic_Matrix(root, coords=None, mode='g', f=False, sub=True):
                        Severity: Major
                        Found in galgebra/lt.py by sonar-python

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

                        Noncompliant Code Example

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

                        def MyFunction(a,b):
    ...

                        Compliant Solution

                        def my_function(a,b):
    ...

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

                        def Matrix_to_dictionary(mat_rep, basis):
                        Severity: Major
                        Found in galgebra/lt.py by sonar-python

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

                        Noncompliant Code Example

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

                        def MyFunction(a,b):
    ...

                        Compliant Solution

                        def my_function(a,b):
    ...

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

                        def Dictionary_to_Matrix(dict_rep, ga):
                        Severity: Major
                        Found in galgebra/lt.py by sonar-python

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

                        Noncompliant Code Example

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

                        def MyFunction(a,b):
    ...

                        Compliant Solution

                        def my_function(a,b):
    ...

                        There are no issues that match your filters.

                        Category
                        Status