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

Open

def square_root_of_expr(expr, hint='0'):
    """
    If expression is product of even powers then every power is divided by two
    and the absolute value of product is returned.
    If some terms in product are not even powers the sqrt of the absolute value of

• Read up
  Read up

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

Open

    def run(self):
        """Include a file as part of the content of this reST file."""

        # copied from docutils.parsers.rst.directives.misc.Include
        if not self.state.document.settings.file_insertion_enabled:

• Read up
  Read up

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

Open

    def even_odd(self, A: Expr, even: bool = True) -> Expr:  # Return even or odd part of A
        A = expand(A)
        if A.is_commutative and even:
            return A
        if isinstance(A, Add):

• Read up
  Read up

Function scalar_part has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.

Open

    def scalar_part(self, A: _MaybeMv) -> Union[Expr, int]:

        if isinstance(A, mv.Mv):
            return self.scalar_part(A.obj)
        else:

• Read up
  Read up

Function ReciprocalFrame has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.

Open

    def ReciprocalFrame(self, basis: Sequence[_mv.Mv], mode: str = 'norm') -> Tuple[_mv.Mv, ...]:
        r"""
        Compute the reciprocal frame :math:`v^i` of a set of vectors :math:`v_i`.

        Parameters

• Read up
  Read up

Function remove_scalar_part has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.

Open

    def remove_scalar_part(self, A: _MaybeMv) -> Union[Expr, int]:
        """
        Return non-commutative part (sympy object) of ``A.obj``.
        """
        if isinstance(A, mv.Mv):

• Read up
  Read up

Function split_multivector has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.

Open

    def split_multivector(self, A: _MaybeMv) -> Tuple[Union[Expr, int], Union[Expr, int]]:
        """
        Split multivector :math:`A` into commutative part :math:`a` and
        non-commutative part :math:`A'` so that :math:`A = a+A'`
        """

• Read up
  Read up

Function gxpdf has 12 arguments (exceeds 4 allowed). Consider refactoring.

Open

def gxpdf(filename=None, paper=(14, 11), crop=False, png=False, prog=False, debug=False, pt='10pt', pdfprog='pdflatex', evince=True, rm=True, null=True, documentclass='book'):

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

• Read up
  Read up

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

Open

def nc_subs(expr, base_keys, base_values=None):
    """
    See if expr contains nc (non-commutative) keys in base_keys and substitute corresponding
    value in base_values for nc key.  This was written since standard
    sympy subs was very slow in performing this operation for non-commutative

• Read up
  Read up

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

Open

    def g_inv(self) -> Matrix:
        """ inverse of metric tensor, g^{ij} """
        g_inv = eye(self.n)

        for i in self.n_range:

• Read up
  Read up

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

Open

    def er_blade(self, er, blade, mode='*', left=True):
        r"""
        Product (``*``, ``^``, ``|``, ``<``, ``>``) of reciprocal basis vector
        'er' and basis
        blade 'blade' needed for application of derivatives to

• Read up
  Read up

Function mv has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

Open

    def mv(self, root=None, *args, **kwargs) -> Union[_mv.Mv, Tuple[_mv.Mv, ...]]:
        """
        Instanciate and return a multivector for this, 'self',
        geometric algebra.
        """

• Read up
  Read up

Function _update_de_from_rbasis has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

Open

    def _update_de_from_rbasis(self):
        # Replace reciprocal basis vectors with expansion in terms of
        # basis vectors in derivatives of basis vectors.
        de = self.de
        if de is not None:

• Read up
  Read up

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

Open

    def __init__(

Function _add_paren has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

Open

def _add_paren(line, re_exprs):
    paren_flg = False
    if (line[0] == '(') and (line[-1] == ')'):
        paren_flg = True
        line = line[1:-1]

• Read up
  Read up

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

• Read up
  Read up

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

Open

    def __mul__(self, LT):

        if isinstance(LT, Lt):

            if self.Ga != LT.Ga:

• Read up
  Read up

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

Open

    def dot_orthogonal(V1, V2, g=None):
        """
        Returns the dot product of two vectors in an orthogonal coordinate
        system.  V1 and V2 are lists of sympy expressions.  g is
        a list of constants that gives the signature of the vector space to

• Read up
  Read up

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

Open

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

        self = self._with_sorted_terms()

• Read up
  Read up