Sign upLogin

pygae/galgebra

View on GitHub
Star
galgebra/mv.py

Summary

Maintainability
F
2 wks
Test Coverage

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

        assert not isinstance(A, Mv)
Severity: Info
Found in galgebra/mv.py by bandit

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

        assert not isinstance(A, Mv)
Severity: Info
Found in galgebra/mv.py by bandit

File mv.py has 1630 lines of code (exceeds 250 allowed). Consider refactoring.
Open

"""
Multivector and Linear Multivector Differential Operator
"""

import copy
Severity: Major
Found in galgebra/mv.py - About 4 days to fix

    Mv has 80 functions (exceeds 20 allowed). Consider refactoring.
    Open

    class Mv(printer.GaPrintable):
    """
    Wrapper class for multivector objects (``self.obj``) so that it is easy
    to overload operators (``*``, ``^``, ``|``, ``<``, ``>``)  for the various
    multivector products and for printing.
    Severity: Major
    Found in galgebra/mv.py - About 1 day to fix

      Function _latex has a Cognitive Complexity of 58 (exceeds 5 allowed). Consider refactoring.
      Open

          def _latex(self, print_obj: _LatexPrinter) -> str:

        if self.obj == S.Zero:
            return ZERO_STR
      Severity: Minor
      Found in galgebra/mv.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 _latex has a Cognitive Complexity of 47 (exceeds 5 allowed). Consider refactoring.
      Open

          def _latex(self, print_obj: _LatexPrinter) -> str:
        if len(self.terms) == 0:
            return ZERO_STR

        self.consolidate_coefs()
      Severity: Minor
      Found in galgebra/mv.py - About 7 hrs to fix

      Cognitive Complexity

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

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

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

      Further reading

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

          def _sympystr(self, print_obj: printer.GaPrinter) -> str:

        # note: this just replaces `self` for the rest of this function
        obj = expand(self.obj)
        obj = metric.Simp.apply(obj)
      Severity: Minor
      Found in galgebra/mv.py - About 7 hrs to fix

      Cognitive Complexity

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

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

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

      Further reading

      Cyclomatic complexity is too high in method _latex. (28)
      Open

          def _latex(self, print_obj: _LatexPrinter) -> str:

        if self.obj == S.Zero:
            return ZERO_STR
      Severity: Minor
      Found in galgebra/mv.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 _sympystr has a Cognitive Complexity of 31 (exceeds 5 allowed). Consider refactoring.
      Open

          def _sympystr(self, print_obj: _StrPrinter) -> str:
        if len(self.terms) == 0:
            return ZERO_STR

        mv_terms = self.Dop_mv_expand(modes=simplify)
      Severity: Minor
      Found in galgebra/mv.py - About 4 hrs to fix

      Cognitive Complexity

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

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

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

      Further reading

      Cyclomatic complexity is too high in method Mul. (19)
      Open

          @staticmethod
    def Mul(dopl, dopr, op='*'):  # General multiplication of Dop's
        # cmpflg is True if the Dop operates on the left argument and
        # False if the Dop operates on the right argument
      Severity: Minor
      Found in galgebra/mv.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 _sympystr. (19)
      Open

          def _sympystr(self, print_obj: printer.GaPrinter) -> str:

        # note: this just replaces `self` for the rest of this function
        obj = expand(self.obj)
        obj = metric.Simp.apply(obj)
      Severity: Minor
      Found in galgebra/mv.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 27 (exceeds 5 allowed). Consider refactoring.
      Open

          def Mul(dopl, dopr, op='*'):  # General multiplication of Dop's
        # cmpflg is True if the Dop operates on the left argument and
        # False if the Dop operates on the right argument

        if isinstance(dopl, Dop) and isinstance(dopr, Dop):
      Severity: Minor
      Found in galgebra/mv.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

      Dop has 30 functions (exceeds 20 allowed). Consider refactoring.
      Open

      class Dop(dop._BaseDop):
    r"""
    Differential operator class for multivectors.  The operators are of
    the form
      Severity: Minor
      Found in galgebra/mv.py - About 3 hrs to fix

        Function characterise_Mv has a Cognitive Complexity of 25 (exceeds 5 allowed). Consider refactoring.
        Open

            def characterise_Mv(self) -> None:
        if self.char_Mv:
            return
        obj = expand(self.obj)
        if isinstance(obj, numbers.Number):
        Severity: Minor
        Found in galgebra/mv.py - About 3 hrs to fix

        Cognitive Complexity

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

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

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

        Further reading

        Function Dop_mv_expand has a Cognitive Complexity of 24 (exceeds 5 allowed). Consider refactoring.
        Open

            def Dop_mv_expand(self, modes=None) -> List[Tuple[Expr, Expr]]:
        coefs = []
        bases = []
        self.consolidate_coefs()
        Severity: Minor
        Found in galgebra/mv.py - About 3 hrs to fix

        Cognitive Complexity

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

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

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

        Further reading

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

            def __init__(self, *args, ga, recp=None, coords=None, **kwargs):
        """
        __init__(self, *args, ga, recp=None, **kwargs)

        Note this constructor is overloaded, based on the type and number of
        Severity: Minor
        Found in galgebra/mv.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. (13)
        Open

            def _latex(self, print_obj: _LatexPrinter) -> str:
        if len(self.terms) == 0:
            return ZERO_STR

        self.consolidate_coefs()
        Severity: Minor
        Found in galgebra/mv.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 exp has a Cognitive Complexity of 21 (exceeds 5 allowed). Consider refactoring.
        Open

            def exp(self, hint: str = '-') -> 'Mv':  # Calculate exponential of multivector
        """
        Only works if square of multivector is a scalar.  If square is a
        number we can determine if square is > or < zero and hence if
        one should use trig or hyperbolic functions in expansion.  If
        Severity: Minor
        Found in galgebra/mv.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

        Function compare has a Cognitive Complexity of 21 (exceeds 5 allowed). Consider refactoring.
        Open

        def compare(A: Mv, B: Mv) -> Union[Expr, int]:
    """
    Determine if ``B = c*A`` where c is a scalar.  If true return c
    otherwise return 0.
    """
        Severity: Minor
        Found in galgebra/mv.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 characterise_Mv. (12)
        Open

            def characterise_Mv(self) -> None:
        if self.char_Mv:
            return
        obj = expand(self.obj)
        if isinstance(obj, numbers.Number):
        Severity: Minor
        Found in galgebra/mv.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__. (11)
        Open

            def __init__(self, *args, ga, recp=None, coords=None, **kwargs):
        """
        __init__(self, *args, ga, recp=None, **kwargs)

        Note this constructor is overloaded, based on the type and number of
        Severity: Minor
        Found in galgebra/mv.py by radon

        Cyclomatic Complexity

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

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

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

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

        Cyclomatic complexity is too high in function compare. (11)
        Open

        def compare(A: Mv, B: Mv) -> Union[Expr, int]:
    """
    Determine if ``B = c*A`` where c is a scalar.  If true return c
    otherwise return 0.
    """
        Severity: Minor
        Found in galgebra/mv.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 diff has a Cognitive Complexity of 19 (exceeds 5 allowed). Consider refactoring.
        Open

            def diff(self, coord) -> 'Mv':
        if self.Ga.coords is None:
            obj = diff(self.obj, coord)
        elif coord not in self.Ga.coords:
            if self.Ga.par_coords is None:
        Severity: Minor
        Found in galgebra/mv.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 Dop_mv_expand. (10)
        Open

            def Dop_mv_expand(self, modes=None) -> List[Tuple[Expr, Expr]]:
        coefs = []
        bases = []
        self.consolidate_coefs()
        Severity: Minor
        Found in galgebra/mv.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_from_terms. (10)
        Open

            def __init_from_terms(self, terms: Union[
        List[Tuple[Mv, dop.Pdop]],
        List[Tuple[dop.Sdop, Mv]],
    ]):
        if len(terms) == 0:
        Severity: Minor
        Found in galgebra/mv.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 _sympystr. (10)
        Open

            def _sympystr(self, print_obj: _StrPrinter) -> str:
        if len(self.terms) == 0:
            return ZERO_STR

        mv_terms = self.Dop_mv_expand(modes=simplify)
        Severity: Minor
        Found in galgebra/mv.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 _make_grade. (10)
        Open

            @staticmethod
    def _make_grade(ga: 'Ga', __name_or_coeffs: Union[str, list, tuple], __grade: int, **kwargs) -> Expr:
        """ Make a pure grade multivector. """
        def add_superscript(root, s):
            if not s:
        Severity: Minor
        Found in galgebra/mv.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 __mul__. (9)
        Open

            def __mul__(self, A):
        if isinstance(A, dop._BaseDop):
            return NotImplemented

        if not isinstance(A, Mv):
        Severity: Minor
        Found in galgebra/mv.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 Add. (9)
        Open

            @staticmethod
    def Add(dop1, dop2):

        if isinstance(dop1, Dop) and isinstance(dop2, Dop):
            if dop1.Ga != dop2.Ga:
        Severity: Minor
        Found in galgebra/mv.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 Mul. (8)
        Open

            @staticmethod
    def Mul(A: 'Mv', B: 'Mv', op: str) -> 'Mv':
        """
        Function for all types of geometric multiplications called by
        overloaded operators for ``*``, ``^``, ``|``, ``<``, and ``>``.
        Severity: Minor
        Found in galgebra/mv.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 blade_coefs. (8)
        Open

            def blade_coefs(self, blade_lst: List['Mv'] = None) -> List[Expr]:
        """
        For a multivector, A, and a list of basis blades, blade_lst return
        a list (sympy expressions) of the coefficients of each basis blade
        in blade_lst
        Severity: Minor
        Found in galgebra/mv.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 exp. (8)
        Open

            def exp(self, hint: str = '-') -> 'Mv':  # Calculate exponential of multivector
        """
        Only works if square of multivector is a scalar.  If square is a
        number we can determine if square is > or < zero and hence if
        one should use trig or hyperbolic functions in expansion.  If
        Severity: Minor
        Found in galgebra/mv.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 Add has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.
        Open

            def Add(dop1, dop2):

        if isinstance(dop1, Dop) and isinstance(dop2, Dop):
            if dop1.Ga != dop2.Ga:
                raise ValueError('In Dop.Add Dop arguments are not from same geometric algebra')
        Severity: Minor
        Found in galgebra/mv.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 diff. (7)
        Open

            def diff(self, coord) -> 'Mv':
        if self.Ga.coords is None:
            obj = diff(self.obj, coord)
        elif coord not in self.Ga.coords:
            if self.Ga.par_coords is None:
        Severity: Minor
        Found in galgebra/mv.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 _make_grade has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.
        Open

            def _make_grade(ga: 'Ga', __name_or_coeffs: Union[str, list, tuple], __grade: int, **kwargs) -> Expr:
        """ Make a pure grade multivector. """
        def add_superscript(root, s):
            if not s:
                return root
        Severity: Minor
        Found in galgebra/mv.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 _arithmetic_op. (6)
        Open

            def _arithmetic_op(self, A, op, name: str):
        """ Common implementation for + and - """
        if isinstance(A, dop._BaseDop):
            return NotImplemented
        Severity: Minor
        Found in galgebra/mv.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 norm. (6)
        Open

            def norm(self, hint: str = '+') -> Expr:
        """
        If A is a multivector and A*A.rev() is a scalar then::

            A.norm() == sqrt(Abs(A*A.rev()))
        Severity: Minor
        Found in galgebra/mv.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 norm has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.
        Open

            def norm(self, hint: str = '+') -> Expr:
        """
        If A is a multivector and A*A.rev() is a scalar then::

            A.norm() == sqrt(Abs(A*A.rev()))
        Severity: Minor
        Found in galgebra/mv.py - About 1 hr to fix

        Cognitive Complexity

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

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

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

        Further reading

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

            def blade_coefs(self, blade_lst: List['Mv'] = None) -> List[Expr]:
        """
        For a multivector, A, and a list of basis blades, blade_lst return
        a list (sympy expressions) of the coefficients of each basis blade
        in blade_lst
        Severity: Minor
        Found in galgebra/mv.py - About 1 hr to fix

        Cognitive Complexity

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

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

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

        Further reading

        Function printeigen has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
        Open

        def printeigen(M):    # Print eigenvalues, multiplicities, eigenvectors of M.
    evects = M.eigenvects()
    for i in range(len(evects)):                   # i iterates over eigenvalues
        print(('Eigenvalue =', evects[i][0], '  Multiplicity =', evects[i][1], ' Eigenvectors:'))
        for j in range(len(evects[i][2])):         # j iterates over eigenvectors of a given eigenvalue
        Severity: Minor
        Found in galgebra/mv.py - About 1 hr to fix

        Cognitive Complexity

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

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

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

        Further reading

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

            def is_blade(self) -> bool:
        """
        True is self is blade, otherwise False
        sets self.blade_flg and returns value
        """
        Severity: Minor
        Found in galgebra/mv.py - About 55 mins to fix

        Cognitive Complexity

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

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

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

        Further reading

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

            def collect(self, deep=False) -> 'Mv':
        """
        group coeffients of blades of multivector
        so there is only one coefficient per grade
        """
        Severity: Minor
        Found in galgebra/mv.py - About 55 mins to fix

        Cognitive Complexity

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

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

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

        Further reading

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

            def _arithmetic_op(self, A, op, name: str):
        """ Common implementation for + and - """
        if isinstance(A, dop._BaseDop):
            return NotImplemented
        Severity: Minor
        Found in galgebra/mv.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 index in terms:
                            c_tmp, base, g_keys = terms[index]
                            terms[index] = (c_tmp + c, base, g_keys)
                        else:
                            terms[index] = (c, base, grade_keys[base])
        Severity: Major
        Found in galgebra/mv.py - About 45 mins to fix

          Avoid deeply nested control flow statements.
          Open

                                  if self.cmpflg:
                            s += str_sdop + '*' + str_base
                        else:
                            s += str_base + '*' + str_sdop
            s += ' + '
          Severity: Major
          Found in galgebra/mv.py - About 45 mins to fix

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

                def reflect_in_blade(self, blade: 'Mv') -> 'Mv':  # Reflect mv in blade
        # See Mv class functions documentation
        if blade.is_blade():
            self.characterise_Mv()
            blade.characterise_Mv()
            Severity: Minor
            Found in galgebra/mv.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 __mul__ has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
            Open

                def __mul__(self, A):
        if isinstance(A, dop._BaseDop):
            return NotImplemented

        if not isinstance(A, Mv):
            Severity: Minor
            Found in galgebra/mv.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 str_sdop[0] == '-' and not isinstance(sdop.terms[0][0], Add):
                            if self.cmpflg:
                                s += str_sdop + str_base
                            else:
                                s += '-' + str_base + ' ' + str_sdop[1:]
            Severity: Major
            Found in galgebra/mv.py - About 45 mins to fix

              Avoid deeply nested control flow statements.
              Open

                                      if self.cmpflg:
                            s += str_sdop + '*' + str_base
                        else:
                            s += '-' + str_base + '*' + str_sdop[1:]
                    else:
              Severity: Major
              Found in galgebra/mv.py - About 45 mins to fix

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

                    def Mul(A: 'Mv', B: 'Mv', op: str) -> 'Mv':
        """
        Function for all types of geometric multiplications called by
        overloaded operators for ``*``, ``^``, ``|``, ``<``, and ``>``.
        """
                Severity: Minor
                Found in galgebra/mv.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 printGS has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
                Open

                def printGS(M, norm=False):  # Print Gram-Schmidt output.
    from sympy import GramSchmidt
    global N
    N = GramSchmidt(M, norm)
    result = '[ '
                Severity: Minor
                Found in galgebra/mv.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 self.cmpflg:
                            s += r'\left ( ' + str_sdop + r'\right ) ' + str_base
                        else:
                            s += str_base + ' ' + r'\left ( ' + str_sdop + r'\right ) '
                    else:
                Severity: Major
                Found in galgebra/mv.py - About 45 mins to fix

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

                      def __init__(self, *args, ga, recp=None, coords=None, **kwargs):
                  Severity: Minor
                  Found in galgebra/mv.py - About 35 mins to fix

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

                    def printrref(matrix, vars="xyzuvwrs"):   # Print rref of matrix with variables.
    rrefmatrix = matrix.rref()[0]
    rows, cols = rrefmatrix.shape
    if len(vars) < cols - 1:
        print('Not enough variables.')
                    Severity: Minor
                    Found in galgebra/mv.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 s
                    Severity: Major
                    Found in galgebra/mv.py - About 30 mins to fix

                      Avoid too many return statements within this function.
                      Open

                                  return selfxA.blade_rep()
                      Severity: Major
                      Found in galgebra/mv.py - About 30 mins to fix

                        Avoid too many return statements within this function.
                        Open

                                    return A > B
                        Severity: Major
                        Found in galgebra/mv.py - About 30 mins to fix

                          Avoid too many return statements within this function.
                          Open

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

                            Avoid too many return statements within this function.
                            Open

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

                              Avoid too many return statements within this function.
                              Open

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

                                Avoid too many return statements within this function.
                                Open

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

                                  Avoid too many return statements within this function.
                                  Open

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

                                    Avoid too many return statements within this function.
                                    Open

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

                                      Avoid too many return statements within this function.
                                      Open

                                                  return selfxA.blade_rep()
                                      Severity: Major
                                      Found in galgebra/mv.py - About 30 mins to fix

                                        Avoid too many return statements within this function.
                                        Open

                                                            return sqrt(Abs(product))
                                        Severity: Major
                                        Found in galgebra/mv.py - About 30 mins to fix

                                          Avoid too many return statements within this function.
                                          Open

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

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

                                                def __init__(self, *args, ga, recp=None, coords=None, **kwargs):
                                            Severity: Critical
                                            Found in galgebra/mv.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 30 to the 15 allowed.
                                            Open

                                                def Mul(dopl, dopr, op='*'):  # General multiplication of Dop's
                                            Severity: Critical
                                            Found in galgebra/mv.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 23 to the 15 allowed.
                                            Open

                                            def compare(A: Mv, B: Mv) -> Union[Expr, int]:
                                            Severity: Critical
                                            Found in galgebra/mv.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 60 to the 15 allowed.
                                            Open

                                                def _latex(self, print_obj: _LatexPrinter) -> str:
                                            Severity: Critical
                                            Found in galgebra/mv.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 48 to the 15 allowed.
                                            Open

                                                def _latex(self, print_obj: _LatexPrinter) -> str:
                                            Severity: Critical
                                            Found in galgebra/mv.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 Add(dop1, dop2):
                                            Severity: Critical
                                            Found in galgebra/mv.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 46 to the 15 allowed.
                                            Open

                                                def _sympystr(self, print_obj: printer.GaPrinter) -> str:
                                            Severity: Critical
                                            Found in galgebra/mv.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 25 to the 15 allowed.
                                            Open

                                                def characterise_Mv(self) -> None:
                                            Severity: Critical
                                            Found in galgebra/mv.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 exp(self, hint: str = '-') -> 'Mv':  # Calculate exponential of multivector
                                            Severity: Critical
                                            Found in galgebra/mv.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 24 to the 15 allowed.
                                            Open

                                                def Dop_mv_expand(self, modes=None) -> List[Tuple[Expr, Expr]]:
                                            Severity: Critical
                                            Found in galgebra/mv.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 32 to the 15 allowed.
                                            Open

                                                def _sympystr(self, print_obj: _StrPrinter) -> str:
                                            Severity: Critical
                                            Found in galgebra/mv.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

                                                            # print 'blade =', blade
                                            Severity: Major
                                            Found in galgebra/mv.py by sonar-python

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

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

                                            See

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

                                            Rename method "Fmt" to prevent any misunderstanding/clash with field "fmt" defined on line 80
                                            Open

                                                def Fmt(self, fmt: int = 1, title: str = None) -> printer.GaPrintable:
                                            Severity: Blocker
                                            Found in galgebra/mv.py by sonar-python

                                            Looking at the set of methods and fields in a class and finding two that differ only by capitalization is confusing to users of the class.

                                            This situation may simply indicate poor naming. Method names should be action-oriented, and thus contain a verb, which is unlikely in the case where both a method and a field have the same name (with or without capitalization differences). However, renaming a public method could be disruptive to callers. Therefore renaming the member is the recommended action.

                                            Noncompliant Code Example

                                            class SomeClass:
    lookUp = false
    def lookup():       # Non-compliant; method name differs from field name only by capitalization
        pass

                                            Compliant Solution

                                            class SomeClass:
    lookUp = false
    def getLookUp():
        pass

                                            Remove this commented out code.
                                            Open

                                                    # print 'args =', args
                                            Severity: Major
                                            Found in galgebra/mv.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

                                                        # coef = simplify(coef)
                                            Severity: Major
                                            Found in galgebra/mv.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

                                                """
    def __eq__(self, A):
        if not isinstance(A, Mv):
            if not self.is_scalar():
                return False
                                            Severity: Major
                                            Found in galgebra/mv.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

                                                        """
            if self_self_rev.scalar() == S.Zero:
                raise ValueError('!!!!In multivector inverse A*A.rev() is zero!!!!')
            """
                                            Severity: Major
                                            Found in galgebra/mv.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

                                                        """
            if self_sq.scalar() == S.Zero:
                raise ValueError('!!!!In multivector inverse, A*A is zero!!!!')
            """
                                            Severity: Major
                                            Found in galgebra/mv.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

                                                        # diff = (self - A).expand()
                                            Severity: Major
                                            Found in galgebra/mv.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"

                                            Either merge this branch with the identical one on line "1060" or change one of the implementations.
                                            Open

                                                            obj = diff(self.obj, coord)
                                            Severity: Major
                                            Found in galgebra/mv.py by sonar-python

                                            Having two branches in the same if structure with the same implementation is at best duplicate code, and at worst a coding error. If the same logic is truly needed for both instances, then they should be combined.

                                            Noncompliant Code Example

                                            if 0 <= a < 10:
    do_the_thing()
elif 10 <= a < 20:
    do_the_other_thing()
elif 20 <= a < 50:
    do_the_thing()  # Noncompliant; duplicates first condition
else:
    do_the_rest()

b = 4 if a > 12 else 4

                                            Compliant Solution

                                            if (0 <= a < 10) or (20 <= a < 50):
    do_the_thing()
elif 10 <= a < 20:
    do_the_other_thing()
else:
    do_the_rest()

b = 4

                                            or 

                                            if 0 <= a < 10:
    do_the_thing()
elif 10 <= a < 20:
    do_the_other_thing()
elif 20 <= a < 50:
    do_the_third_thing()
else:
    do_the_rest()

b = 8 if a > 12 else 4

                                            Either remove or fill this block of code.
                                            Open

                                                                pass
                                            Severity: Major
                                            Found in galgebra/mv.py by sonar-python

                                            Most of the time a block of code is empty when a piece of code is really missing. So such empty block must be either filled or removed.

                                            Noncompliant Code Example

                                            for i in range(3):
    pass

                                            Exceptions

                                            When a block contains a comment, this block is not considered to be empty.

                                            Line too long (80 > 79 characters)
                                            Open

                                                dual_mode_lst = ['+I', 'I+', '+Iinv', 'Iinv+', '-I', 'I-', '-Iinv', 'Iinv-']
                                            Severity: Minor
                                            Found in galgebra/mv.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 (112 > 79 characters)
                                            Open

                                                                            for super_script, base in zip(ga.blade_super_scripts[grade], ga.blades[grade])])
                                            Severity: Minor
                                            Found in galgebra/mv.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.

                                            Too many leading '#' for block comment
                                            Open

                                                ################# Multivector member functions #####################
                                            Severity: Minor
                                            Found in galgebra/mv.py by pep8

                                            Separate inline comments by at least two spaces.

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

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

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

                                            Line too long (92 > 79 characters)
                                            Open

                                                        raise ValueError(str(blade) + 'is not a blade in project_in_blade(self, blade)')
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                        return print_obj._print(printer.coef_simplify(sorted_terms[0][1][0]))
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                        raise ValueError('In < operation Mv arguments are not from same geometric algebra')
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                        # Cannot return `NotImplemented` here, as that would call `A < self`
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                def func(self, fct) -> 'Mv':  # Apply function, fct, to each coefficient of multivector
                                            Severity: Minor
                                            Found in galgebra/mv.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.

                                            Too many leading '#' for block comment
                                            Open

                                            ################# Multivector Differential Operator Class ##############
                                            Severity: Minor
                                            Found in galgebra/mv.py by pep8

                                            Separate inline comments by at least two spaces.

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

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

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

                                            Line too long (84 > 79 characters)
                                            Open

                                                where the :math:`D^{i_{1}...i_{n}}` are multivector functions of the coordinates
                                            Severity: Minor
                                            Found in galgebra/mv.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('In Dop.Add Dop arguments are not from same geometric algebra')
                                            Severity: Minor
                                            Found in galgebra/mv.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 (125 > 79 characters)
                                            Open

                                                            raise ValueError('In Dop.Add complement flags have different values: %s vs. %s' % (dop1.cmpflg, dop2.cmpflg))
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                                raise ValueError('In Dop.Mul Dop arguments are not from same geometric algebra')
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                                    if str_sdop[0] == '-' and not isinstance(sdop.terms[0][0], Add):
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                    raise ValueError(str(v1) + ' and ' + str(v2) + ' not compatible for cross product.')
                                            Severity: Minor
                                            Found in galgebra/mv.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 (110 > 79 characters)
                                            Open

                                                If ``A`` is a *sympy* expression the *sympy* expression :math:`e^{A}` is returned (see :func:`sympy.exp`).
                                            Severity: Minor
                                            Found in galgebra/mv.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 (108 > 79 characters)
                                            Open

                                                            if print_obj._settings['galgebra_mv_fmt'] == 2 and old_grade != grade:  # one grade per line
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                        elif print_obj._settings['galgebra_mv_fmt'] == 2:  # One grade per line
                                            Severity: Minor
                                            Found in galgebra/mv.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.

                                            Ambiguous variable name 'i'
                                            Open

                                                        I = self.Ga.i_inv
                                            Severity: Minor
                                            Found in galgebra/mv.py by pep8

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

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

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

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

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

                                            Line too long (100 > 79 characters)
                                            Open

                                                                return self.Ga.mv(cos(base_n*coefs[0]) + sin(base_n*coefs[0])*(bases[0]/base_n))
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                If :math:`*` is any multivector multiplicative operation then the operator D
                                            Severity: Minor
                                            Found in galgebra/mv.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 not isinstance(dopl, Dop):  # dopl is a scalar or Mv and dopr is Dop
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                    return Dop(dop._eval_derivative_n_times_terms(self.terms, x, n), cmpflg=self.cmpflg, ga=self.Ga)
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                    print(('Eigenvalue =', evects[i][0], '  Multiplicity =', evects[i][1], ' Eigenvectors:'))
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                def _make_scalar(ga: 'Ga', __name_or_value: Union[str, Expr], **kwargs) -> Expr:
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                def __init__(self, *args, ga: 'Ga', cmpflg: bool = False, debug: bool = False) -> None:
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                If ``v1`` and ``v2`` are 3-dimensional Euclidean vectors, compute the vector
                                            Severity: Minor
                                            Found in galgebra/mv.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 (110 > 79 characters)
                                            Open

                                                If :math:`s` is grade of :math:`B` returns :math:`\sum_{r}(-1)^{s(r+1)}B{\left < {A} \right >}_{r}B^{-1}`.
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                                return sum([Symbol(add_superscript(name, super_script), real=True) * base
                                            Severity: Minor
                                            Found in galgebra/mv.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 (116 > 79 characters)
                                            Open

                                                    raise TypeError('In inv() for self =' + str(self) + 'self, or self*self or self*self.rev() is not a scalar')
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                        for k in range(len(evects[i][2][j])):  # k iterates over coordinates of an eigenvector
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                    sorted_terms = sorted(terms, key=operator.itemgetter(0))  # sort via base indexes
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                        expand(coef) * base for coef, base in metric.linear_expand_terms(self.obj)
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                def __init_from_coef_and_pdop(self, coefs: List[Any], pdiffs: List['dop.Pdop']):
                                            Severity: Minor
                                            Found in galgebra/mv.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('In Dop.Mul Dop arguments are not from same geometric algebra')
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                            raise ValueError('In Dop.Mul Dop arguments do not have same cmplfg')
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                        raise ValueError('In Dop.__init__ coefficent list and Pdop list must be same length.')
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                    return Dop(dop._consolidate_terms(self.terms), ga=self.Ga, cmpflg=self.cmpflg)
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                                raise ValueError('In Dop.Mul Dop arguments are not from same geometric algebra')
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                                        s += r'\left ( ' + str_sdop + r'\right ) ' + str_base
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                cross product :math:`v_{1}\times v_{2} = -I{\lp {v_{1}{\wedge}v_{2}} \rp }`.
                                            Severity: Minor
                                            Found in galgebra/mv.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 (112 > 79 characters)
                                            Open

                                                                            for super_script, base in zip(ga.blade_super_scripts[grade], ga.blades[grade])])
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                        raise TypeError('"(' + str(product) + ')" is not a scalar in norm.')
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                        coef.subs(*args, **kwargs) * base for coef, base in metric.linear_expand_terms(self.obj)
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                def _make_vector(ga: 'Ga', __name_or_coeffs: Union[str, list, tuple], **kwargs) -> Expr:
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                def _make_pseudo(ga: 'Ga', __name_or_coeffs: Union[str, list, tuple], **kwargs) -> Expr:
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                                # _make_scalar interprets its coefficient argument differently
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                        raise ValueError('In * operation Mv arguments are not from same geometric algebra')
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                        raise ValueError('In > operation Mv arguments are not from same geometric algebra')
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                def exp(self, hint: str = '-') -> 'Mv':  # Calculate exponential of multivector
                                            Severity: Minor
                                            Found in galgebra/mv.py by pep8

                                            Limit all lines to a maximum of 79 characters.

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

Reports error E501.

                                            Line too long (119 > 79 characters)
                                            Open

                                                Equivalent to ``A.rotate_multivector(itheta, hint)`` where ``itheta`` is the bi-vector blade defining the rotation.
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                If ``f`` is a scalar function ``grad*f`` is the usual gradient of a function.
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                            return sum([Function(add_superscript(name, super_script), real=True)(*f) * base
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                        elif isinstance(args[1], int):  # args[1] = r (integer) Construct grade r multivector
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                        if print_obj._settings['galgebra_mv_fmt'] == 3:  # One base per line
                                            Severity: Minor
                                            Found in galgebra/mv.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 ValueError("%s expression isn't a basis blade" % blade)
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                            if print_obj._settings['galgebra_mv_fmt'] == 3:  # one base per line
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                        # Cannot return `NotImplemented` here, as that would call `A > self`
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                :math:`x_{1},...,x_{n}` and :math:`\partial_{i_{1}...i_{n}}` are partial derivative
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                                        s += str_base + ' ' + r'\left ( ' + str_sdop + r'\right ) '
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                For multivectors with coefficients that contain floating point numbers, this
                                            Severity: Minor
                                            Found in galgebra/mv.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.

                                            Too many leading '#' for block comment
                                            Open

                                            ########################### Multivector Class ##########################
                                            Severity: Minor
                                            Found in galgebra/mv.py by pep8

                                            Separate inline comments by at least two spaces.

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

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

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

                                            Line too long (105 > 79 characters)
                                            Open

                                                def _make_grade(ga: 'Ga', __name_or_coeffs: Union[str, list, tuple], __grade: int, **kwargs) -> Expr:
                                            Severity: Minor
                                            Found in galgebra/mv.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 (107 > 79 characters)
                                            Open

                                                                return sum([Function(add_superscript(name, super_script), real=True)(*ga.coords) * base
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                        raise ValueError('In ^ operation Mv arguments are not from same geometric algebra')
                                            Severity: Minor
                                            Found in galgebra/mv.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 (102 > 79 characters)
                                            Open

                                                                return self.Ga.mv(cosh(base_n*coefs[0]) + sinh(base_n*coefs[0])*(bases[0]/base_n))
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                    for acoef, abase, bcoef, bbase in zip(Acoefs[1:], Abases[1:], Bcoefs[1:], Bbases[1:]):
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                                if str_sdop[0] == '-' and not isinstance(sdop.terms[0][0], Add):
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                            def printrref(matrix, vars="xyzuvwrs"):   # Print rref of matrix with variables.
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                    elif len(args) == 1 and not isinstance(args[0], str):  # copy constructor
                                            Severity: Minor
                                            Found in galgebra/mv.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('{!r} is not an allowed multivector type.'.format(mode))
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                        raise TypeError('"(' + str(product) + ')**2" is not a scalar in norm2.')
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                            raise ValueError('!!!!In multivector inverse A*A.rev() is zero!!!!')
                                            Severity: Minor
                                            Found in galgebra/mv.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 (108 > 79 characters)
                                            Open

                                                                        for super_script, base in zip(ga.blade_super_scripts[grade], ga.blades[grade])])
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                def _make_bivector(ga: 'Ga', __name_or_coeffs: Union[str, list, tuple], **kwargs) -> Expr:
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                        raise ValueError(str(blade) + 'is not a blade in reflect_in_blade(self, blade)')
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                            dop2 = Dop([(dop2, dop.Pdop({}))], cmpflg=dop1.cmpflg, ga=dop1.Ga)
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                            ################################# Alan Macdonald's additions #########################
                                            Severity: Minor
                                            Found in galgebra/mv.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.

                                            Too many leading '#' for block comment
                                            Open

                                            ################################# Alan Macdonald's additions #########################
                                            Severity: Minor
                                            Found in galgebra/mv.py by pep8

                                            Separate inline comments by at least two spaces.

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

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

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

                                            Line too long (103 > 79 characters)
                                            Open

                                                    for j in range(len(evects[i][2])):         # j iterates over eigenvectors of a given eigenvalue
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                            def correlation(u, v, dec=3):  # Compute the correlation coefficient of vectors u and v.
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                ``-I*(grad^A)`` is the curl of ``A`` (I is the pseudo scalar for the geometric
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                                for coef, base in zip(coeffs, ga.blades[grade][:len(coeffs)])])
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                        sorted_terms = sorted(terms, key=operator.itemgetter(0))  # sort via base indexes
                                            Severity: Minor
                                            Found in galgebra/mv.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.

                                            Ambiguous variable name 'i'
                                            Open

                                                        I = self.Ga.i
                                            Severity: Minor
                                            Found in galgebra/mv.py by pep8

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

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

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

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

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

                                            Line too long (82 > 79 characters)
                                            Open

                                                            dop1 = Dop([(dop1, dop.Pdop({}))], cmpflg=dop2.cmpflg, ga=dop2.Ga)
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                for i in range(len(evects)):                   # i iterates over eigenvalues
                                            Severity: Minor
                                            Found in galgebra/mv.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.

                                            Too many leading '#' for block comment
                                            Open

                                                ################### Multivector initialization #####################
                                            Severity: Minor
                                            Found in galgebra/mv.py by pep8

                                            Separate inline comments by at least two spaces.

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

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

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

                                            Line too long (95 > 79 characters)
                                            Open

                                                        raise ValueError('In | operation Mv arguments are not from same geometric algebra')
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                        raise ValueError('!!!!Multivector power can only be to integer power!!!!')
                                            Severity: Minor
                                            Found in galgebra/mv.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

                                                        return Dop(dop._merge_terms(dop1.terms, dop2.terms), cmpflg=dop1.cmpflg, ga=dop1.Ga)
                                            Severity: Minor
                                            Found in galgebra/mv.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 "printGS" to match the regular expression ^[a-z_][a-z0-9_]{2,}$.
                                            Open

                                            def printGS(M, norm=False):  # Print Gram-Schmidt output.
                                            Severity: Major
                                            Found in galgebra/mv.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 "Nga" to match the regular expression ^[a-z_][a-z0-9_]{2,}$.
                                            Open

                                            def Nga(x, prec=5):
                                            Severity: Major
                                            Found in galgebra/mv.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