Function _of_basis_blades_ortho has a Cognitive Complexity of 20 (exceeds 5 allowed). Consider refactoring.

Open

    def _of_basis_blades_ortho(self, blade1: Symbol, blade2: Symbol):
        # dot (|), left (<), and right (>) products
        # dot product for orthogonal basis
        index1 = self._ga.indexes_to_blades_dict.inverse[blade1]
        index2 = self._ga.indexes_to_blades_dict.inverse[blade2]

• Read up
  Read up

Function linear_expand has a Cognitive Complexity of 19 (exceeds 5 allowed). Consider refactoring.

Open

def linear_expand(expr):
    """
    linear_expand takes an expression that is the sum of a scalar
    expression and a linear combination of noncommutative terms with
    scalar coefficients and generates lists of coefficients and

• Read up
  Read up

Function normalize_metric has a Cognitive Complexity of 19 (exceeds 5 allowed). Consider refactoring.

Open

    def normalize_metric(self):

        # normalize derivatives
        if self.de is not None:
            # Generate mapping for renormalizing reciprocal basis vectors

• Read up
  Read up

Function reduce_basis_loop has a Cognitive Complexity of 19 (exceeds 5 allowed). Consider refactoring.

Open

    def reduce_basis_loop(g, blst):
        r"""
        blst is a list of integers :math:`[i_{1},\ldots,i_{r}]` representing the geometric
        product of r basis vectors :math:`a_{{i_1}}\cdots a_{{i_r}}`. :meth:`reduce_basis_loop`
        searches along the list :math:`[i_{1},\ldots,i_{r}]` untill it finds :math:`i_{j} = i_{j+1}`

• Read up
  Read up

Function oprint has a Cognitive Complexity of 19 (exceeds 5 allowed). Consider refactoring.

Open

def oprint(*args, dict_mode=False):
    """
    Debug printing for iterated (list/tuple/dict/set) objects. args is
    of form ``(title1, object1, title2, object2, ...)`` and prints::

• Read up
  Read up

Function diff has a Cognitive Complexity of 19 (exceeds 5 allowed). Consider refactoring.

Open

    def diff(self, coord) -> 'Mv':
        if self.Ga.coords is None:
            obj = diff(self.obj, coord)
        elif coord not in self.Ga.coords:
            if self.Ga.par_coords is None:

• Read up
  Read up

Function _latex has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.

Open

    def _latex(self, print_obj):
        if len(self.terms) == 0:
            return ZERO_STR

        self = self._with_sorted_terms()

• Read up
  Read up

Function grade_decomposition has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.

Open

    def grade_decomposition(self, A: _MaybeMv) -> Dict[int, _MaybeMv]:
        """
        Returns dictionary with grades as keys of grades of A.  For example
        if A is a rotor the dictionary keys would be 0 and 2. For a vector
        the single key would be 1.  Note A can be input as a multivector or

• Read up
  Read up

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

Open

    def __init__(self, f, Ga, nargs=None, fct=False):
        #  f is a function, a multivector, a string, or a component expression
        #  self.f is a function or None such as T | a_1 where T and a_1 are vectors
        #  self.fvalue is a component expression such as
        #  T_x*a_1__x+T_y*a_1__y+T_z*a_1__z for a rank 1 tensor in 3 space and all

• Read up
  Read up

Function reduce_basis has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.

Open

    def reduce_basis(self, blst):
        r"""
        Repetitively applies :meth:`reduce_basis_loop` to `blst`
        product representation until normal form is
        realized for non-orthogonal basis

• Read up
  Read up

Lt has 21 functions (exceeds 20 allowed). Consider refactoring.

Open

class Lt(printer.GaPrintable):
    r"""
    A Linear Transformation

    Except for the versor representation, the linear transformation

Sdop has 21 functions (exceeds 20 allowed). Consider refactoring.

Open

class Sdop(_BaseDop):
    """
    Scalar differential operator is of the form (Einstein summation)

    .. math:: D = c_{i}*D_{i}

Mlt has 21 functions (exceeds 20 allowed). Consider refactoring.

Open

class Mlt(printer.GaPrintable):
    r"""
    A multilinear transformation (mlt) is a multilinear multivector function of
    a list of vectors (``*args``) :math:`F(v_1,...,v_r)` where for any argument slot
    :math:`j` we have (:math:`a` is a scalar and :math:`u_j` a vector)

Function r_basis has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.

Open

    def r_basis(self) -> List[Expr]:
        r"""
        Reciprocal basis vectors :math:`e^{j}` as linear combination of basis vector symbols.

        These satisfy

• Read up
  Read up

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

Open

    def Add(dop1, dop2):

        if isinstance(dop1, Dop) and isinstance(dop2, Dop):
            if dop1.Ga != dop2.Ga:
                raise ValueError('In Dop.Add Dop arguments are not from same geometric algebra')

• Read up
  Read up

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

Open

    def __init__(self, bases, *, wedge=True, **kwargs):
        """
        Parameters
        ----------
        bases :

• Read up
  Read up

Function of_basis_blades has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.

Open

    def of_basis_blades(self, blade1: Symbol, blade2: Symbol) -> Expr:
        # geometric (*) product for orthogonal basis
        if self._ga.is_ortho:
            index1 = self._ga.indexes_to_blades_dict.inverse[blade1]
            index2 = self._ga.indexes_to_blades_dict.inverse[blade2]

• Read up
  Read up

Function _make_grade has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.

Open

    def _make_grade(ga: 'Ga', __name_or_coeffs: Union[str, list, tuple], __grade: int, **kwargs) -> Expr:
        """ Make a pure grade multivector. """
        def add_superscript(root, s):
            if not s:
                return root

• Read up
  Read up

Function expand_expr has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.

Open

    def expand_expr(expr, ga):
        lst_expr = []
        expr = expand(expr)
        for term in expr.args:
            coef = S.One

• Read up
  Read up

Function xpdf has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.

Open

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

    """
    Post processes LaTeX output (see comments below), adds preamble and
    postscript, generates tex file, inputs file to latex, displays resulting

• Read up
  Read up