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
        """

• Read up
  Read up

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
        """

• Read up
  Read up

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

Open

def _eval_derivative_n_times_terms(terms, x, n):
    for i in range(n):
        new_terms = []
        for k, term in enumerate(terms):
            dc = _basic_diff(term[0], x)

• Read up
  Read up

Avoid deeply nested control flow statements.

Open

                        if self.cmpflg:
                            s += str_sdop + '*' + str_base
                        else:
                            s += '-' + str_base + '*' + str_sdop[1:]
                    else:

Avoid deeply nested control flow statements.

Open

                    if _contains_interval(group, group_down):
                        level_lst[ilevel][igroup].append(igroup_down)
                    igroup_down += 1

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

Open

    def connection(self, rbase, key_base, mode, left):
        """
        Compute required multivector connections of the form
        (Einstein summation convention) :math:`e^{j}*(D_{j}e_{i_{1}...i_{r}})`
        and :math:`(D_{j}e_{i_{1}...i_{r}})*e^{j}` where :math:`*` could be

• Read up
  Read up

Avoid deeply nested control flow statements.

Open

                    if not f:
                        mat[row, col] = Symbol(element, real=True)
                    else:
                        mat[row, col] = Function(element)(*coords)

Avoid deeply nested control flow statements.

Open

                        if self.cmpflg:
                            s += str_sdop + '*' + str_base
                        else:
                            s += str_base + '*' + str_sdop
            s += ' + '

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

Open

    def __call__(self, *args):
        """
        Evaluate the multilinear function for the given vector arguments.
        Note that a sympy scalar is returned, *not* a multilinear function.
        """

• Read up
  Read up

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

• Read up
  Read up

Avoid deeply nested control flow statements.

Open

                        for l in ga.n_range:
                            s += dxdu[k][i] * dxdu[l][j] * g_base[k, l].subs(sub_pairs)
                    g[i, j] = trigsimp(s)

Avoid deeply nested control flow statements.

Open

                        if x != S.Zero:
                            dA += reduce(operator.mul, c, x)

Avoid deeply nested control flow statements.

Open

                    if row <= col:
                        element = root + pos + row_index + col_index
                    else:
                        element = root + pos + col_index + row_index
                    if not f:

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 ``>``.
        """

• Read up
  Read up

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 = '[ '

• Read up
  Read up

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:

Avoid deeply nested control flow statements.

Open

                        for i in range(len(g)):
                            m[i, i] = g[i]
                        self.g = m

Avoid deeply nested control flow statements.

Open

                    if row <= col:
                        sign = S.One
                        element = root + pos + row_index + col_index
                    else:
                        sign = -S.One

Avoid deeply nested control flow statements.

Open

                    if not f:
                        mat[row, col] = sign * Symbol(element, real=True)
                    else:
                        mat[row, col] = sign * Function(element)(*coords)
        else:

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])