Avoid deeply nested control flow statements.

Open

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

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

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

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

Open

    def _sympystr(self, print_obj):

        if self.spinor:
            return 'R = ' + print_obj._print(self.R)
        else:

• 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

                        if '_' in name or '^' in name:
                            name = r'\left ( ' + name + r'\right )^{' + exp + '}'
                        else:
                            name += '^{' + exp + '}'

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

Open

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

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

Open

    def setup(basis, metric=None, coords=None, rframe=False, debug=False, curv=(None, None)) -> list:

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

Open

def Symbolic_Matrix(root, coords=None, mode='g', f=False, sub=True):

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

Open

        def _repr_latex_(self):
            f = None
            try:
                # This isn't perfect, in principle there could be multiple
                # active IPython's with different configurations.

• Read up
  Read up

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

Open

    def Add(sdop1, sdop2):
        if isinstance(sdop1, Sdop) and isinstance(sdop2, Sdop):
            return Sdop(_merge_terms(sdop1.terms, sdop2.terms))
        else:
            # convert values to multiplicative operators

• Read up
  Read up

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

Open

def _unparse_paren(level_lst):
    line = level_lst[0][0][0]
    for level in level_lst[1:]:
        for group in level:
            new_string = group[-1]

• Read up
  Read up

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

Open

def _consolidate_terms(terms):
    """
    Remove zero coefs and consolidate coefs with repeated pdiffs.
    """
    new_coefs = []

• Read up
  Read up

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

Open

    def __init__(self, *args):
        if len(args) == 1:
            if isinstance(args[0], Symbol):
                self.__init_from_symbol(*args)
            elif isinstance(args[0], (list, tuple)):

• Read up
  Read up

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.')

• Read up
  Read up

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

Open

    def _print_Derivative(self, expr):
        # Break the following to support both py 2 & 3
        # function, *diff_args = expr.args
        function = expr.args[0]
        diff_args = expr.args[1:]

• Read up
  Read up

Avoid too many return statements within this function.

Open

                    return (0, A)

Avoid too many return statements within this function.

Open

        return s

Avoid too many return statements within this function.

Open

            return selfxA.blade_rep()

Avoid too many return statements within this function.

Open

                    return 0