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

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

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

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

Avoid deeply nested control flow statements.

Open

                    if row == col:
                        sign = S.Zero
                    if not f:

Avoid deeply nested control flow statements.

Open

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

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:

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

• Read up
  Read up

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

• 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 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:]

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 row <= col:
                        sign = S.One
                        element = root + pos + row_index + col_index
                    else:
                        sign = -S.One

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 row <= col:
                        element = root + pos + row_index + col_index
                    else:
                        element = root + pos + col_index + row_index
                    if not f:

Avoid deeply nested control flow statements.

Open

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

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

Open

    def matrix(self) -> Matrix:
        r"""
        Returns the matrix representation of the linear transformation,
        :math:`L`, defined by :math:`{{L}\lp {{{\eb}}_{i}} \rp } = L_{ij}{{\eb}}_{j}`
        where :math:`L_{ij}` is the matrix representation.

• Read up
  Read up

Avoid deeply nested control flow statements.

Open

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

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

Avoid deeply nested control flow statements.

Open

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