Function xpdf has 8 arguments (exceeds 4 allowed). Consider refactoring.

Open

def xpdf(filename=None, paper=(14, 11), crop=False, png=False, prog=False, debug=False, pt='10pt', pdfprog='pdflatex'):

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

Open

    def __init__(self, __u, __coords, *, ga, norm=False, name=None, root='e', debug=False):

Consider simplifying this complex logical expression.

Open

        if expr.exp.is_Rational and abs(expr.exp.p) == 1 and expr.exp.q != 1:
            #base = self._print(expr.base)
            expq = expr.exp.q

            if expq == 2:

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 _latex has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

    def _latex(self, print_obj):
        parts = []
        for base in self.Ga.basis:           # base is a basis symbol
            if self.versor:
                b = mv.Mv(base, ga=self.Ga)  # b is the corresponding basis vector

• 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

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

Avoid deeply nested control flow statements.

Open

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

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)

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

Open

    def _sympystr(self, print_obj):

        if self.versor:    # ## GSG: changed `self.spinor` to `self.versor` ###
            return 'R = ' + print_obj._print(self.V)
        else:

• Read up
  Read up

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

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

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

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

                        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 self.cmpflg:
                            s += str_sdop + '*' + str_base
                        else:
                            s += str_base + '*' + str_sdop
            s += ' + '

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 '_' in name or '^' in name:
                            name = r'\left ( ' + name + r'\right )^{' + exp + '}'
                        else:
                            name += '^{' + exp + '}'

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