Avoid too many return statements within this function.

Open

                    return (A, 0)

Avoid too many return statements within this function.

Open

                return 0

Avoid too many return statements within this function.

Open

        return c

Avoid too many return statements within this function.

Open

            return r"\frac{%s}{%s}" % \

Avoid too many return statements within this function.

Open

                        return tex[1:].strip()

Avoid too many return statements within this function.

Open

                return r"{%s}^{%s}" % (self._print(expr.base), self._print(expr.exp))

Avoid too many return statements within this function.

Open

                return tex % (self._print(expr.base),

Function Christoffel_symbols has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

    def Christoffel_symbols(self, mode=1):
        """
        mode = 1  Christoffel symbols of the first kind
        mode = 2  Christoffel symbols of the second kind
        """

• Read up
  Read up

Function blade_expansion_dict has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

    def blade_expansion_dict(self) -> OrderedDict[Symbol, Expr]:
        """ dictionary expanding blade basis in terms of base basis """

        blade_expansion_dict = OrderedDict()

• Read up
  Read up

Function grades has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

    def grades(self, A: Expr) -> List[int]:  # Return list of grades present in A
        A = self.base_to_blade_rep(A)
        A = expand(A)
        blades = set()
        if isinstance(A, Add):

• Read up
  Read up

Function adj has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

    def adj(self) -> 'Lt':
        r"""
        Returns the adjoint (a linear transformation) of the linear
        transformation, :math:`L`, defined by :math:`a\cdot{{L}\lp {b} \rp } = b\cdot{{\bar{L}}\lp {a} \rp }`
        where :math:`a` and :math:`b` are any two vectors in the tangent space

• Read up
  Read up

Function blade_reduce has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

    def blade_reduce(lst: List[int]) -> Tuple[int, Optional[List[int]]]:
        """
        Reduce wedge product of basis vectors to normal order.

        `lst` is a list of indicies of basis vectors.  blade_reduce sorts the list

• Read up
  Read up

Function base_expansion_dict has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

    def base_expansion_dict(self) -> OrderedDict[Symbol, Expr]:
        """ dictionary expanding base basis in terms of blade basis """
        base_expansion_dict = OrderedDict()

        for base, blade, index in zip(self.bases.flat, self.blades.flat, self.indexes.flat):

• Read up
  Read up

Function parse_line has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

def parse_line(line: str, op_order: List[str]) -> str:
    line = line.replace(' ', '')
    level_lst = _parse_paren(line)
    ilevel = 0
    for level in level_lst:

• Read up
  Read up

Function Mul has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

    def Mul(self, A: Expr, B: Expr, mode: str = '*') -> Expr:  # Unifies all products into one function
        if mode == '*':
            return self.mul(A, B)
        elif mode == '^':
            return self.wedge(A, B)

• Read up
  Read up

Function _split_name has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

    def _split_name(self):
        sub_str = []
        root_str = []
        for basis_vec in self.args:
            split_lst = basis_vec.name.split('_')

• Read up
  Read up

Function flatten has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

def flatten(x):
    result = []

    for el in x:
        if isinstance(x, collections.Iterable) and not isstr(el):

• Read up
  Read up