Merge pull request #241 from eric-wieser/fix-easy-flake8

Fix easy issues with flake8

Author: utensil

galgebra/deprecated.py

@@ -3,6 +3,7 @@
 
 ################################# MV class for backward compatibility ###################
 
+
 class MV(Mv):
 
     @staticmethod
@@ -33,7 +34,6 @@ def setup(basis, metric=None, coords=None, rframe=False, debug=False, curv=(None
         else:
             return list(MV.GA.mv())
 
-
     def __init__(self, base, mvtype, fct=None, blade_rep=True):
         kwargs = {}
         if fct is not None:

galgebra/dop.py

@@ -58,10 +58,10 @@ def _eval_derivative_n_times_terms(terms, x, n):
         for k, term in enumerate(terms):
             dc = _basic_diff(term[0], x)
             pd = _basic_diff(term[1], x)
-            #print 'D0, term, dc, pd =', D0, term, dc, pd
+            # print 'D0, term, dc, pd =', D0, term, dc, pd
             if dc != 0:
                 new_terms.append((dc, term[1]))
-            if pd != 0 :
+            if pd != 0:
                 new_terms.append((term[0], pd))
         terms = new_terms
     return _consolidate_terms(terms)

galgebra/ga.py

@@ -26,6 +26,7 @@
 one = S(1)
 zero = S(0)
 
+
 def all_same(items):
     return all(x == items[0] for x in items)
 
@@ -138,6 +139,7 @@ def nc_subs(expr, base_keys, base_values=None):
 _T = TypeVar('T')
 _U = TypeVar('T')
 
+
 class GradedTuple(Tuple[Tuple[_T, ...], ...]):
     """ A nested tuple grouped by grade.
 
@@ -352,7 +354,6 @@ class Ga(metric.Metric):
                'sph3d': 'r,theta,phi:[1,X[0]**2,X[0]**2*cos(X[1])**2]:[1,1,0]:norm=True',
                'para3d': 'u,v,z:[u**2+v**2,u**2+v**2,1]:[1,1,0]:norm=True'}
 
-
     @staticmethod
     def dual_mode(mode='I+'):
         """
@@ -476,15 +477,15 @@ def __init__(self, bases, *, wedge=True, **kwargs):
             if self.e_sq == S(0):
                 self.sing_flg = True
                 print('!!!!If I**2 = 0, I cannot be normalized!!!!')
-                #raise ValueError('!!!!If I**2 = 0, I cannot be normalized!!!!')
+                # raise ValueError('!!!!If I**2 = 0, I cannot be normalized!!!!')
             if self.e_sq > S(0):
                 self.i = self.e/sqrt(self.e_sq)
                 self.i_inv = self.i
             else:  # I**2 = -1
                 self.i = self.e/sqrt(-self.e_sq)
                 self.i_inv = -self.i
         else:
-            if self.Isq == '+': # I**2 = 1
+            if self.Isq == '+':  # I**2 = 1
                 self.i = self.e/sqrt(self.e_sq)
                 self.i_inv = self.i
             else:  # I**2 = -1
@@ -675,7 +676,7 @@ def bases_dict(self, prefix=None):
         >>> locals().update(ga.bases())
         '''
         if prefix is None:
-            prefix='e'
+            prefix = 'e'
         bl = self.blades.flat[1:]  # do not include the scalar, which is not named
         var_names = [prefix+''.join([k for k in str(b) if k.isdigit()]) for b in bl]
 
@@ -950,7 +951,7 @@ def _build_connection(self):
 
     ######## Functions for Calculation products of blades/bases ########
 
-    #******************** Geometric Product (*) ***********************#
+    # ******************* Geometric Product (*) ********************** #
 
     def geometric_product_basis_blades(self, blade12):
         # geometric (*) product for orthogonal basis
@@ -1036,9 +1037,9 @@ def reduce_basis(self, blst):
                         blst_flg[i] = tmp[2]
                     else:  # blst_expand[i] revised
                         blst_coef[i] = -blst_coef[i]
-                        #if revision force one more pass in case revision
-                        #causes repeated index previous to revised pair of
-                        #indexes
+                        # if revision force one more pass in case revision
+                        # causes repeated index previous to revised pair of
+                        # indexes
                         blst_flg[i] = False
                         blst_expand[i] = tmp[3]
                         blst_coef.append(-blst_coef[i] * tmp[0])
@@ -1106,10 +1107,10 @@ def reduce_basis_loop(g, blst):
                 else:
                     blst1_flg = False  # more revision needed
                 return a1, blst1, blst1_flg, blst
- 
+
         return True  # revision complete, blst in normal order
 
-    #******************* Outer/wedge (^) product **********************#
+    # ****************** Outer/wedge (^) product ********************* #
 
     @staticmethod
     def blade_reduce(lst):
@@ -1151,7 +1152,7 @@ def wedge_product_basis_blades(self, blade12):  # blade12 = blade1*blade2
         else:
             return S(0)
 
-    #****** Dot (|) product, reft (<) and right (>) contractions ******#
+    # ***** Dot (|) product, reft (<) and right (>) contractions ***** #
 
     def _dot_product_grade(self, grade1, grade2, mode):
         """
@@ -1456,7 +1457,6 @@ def split_multivector(self, A):
                 else:
                     return (0, A)
 
-
     def remove_scalar_part(self, A):
         """
         Return non-commutative part (sympy object) of ``A.obj``.
@@ -1478,7 +1478,6 @@ def remove_scalar_part(self, A):
                 else:
                     return A
 
-
     def scalar_part(self, A):
 
         if isinstance(A, mv.Mv):
@@ -1498,7 +1497,6 @@ def scalar_part(self, A):
                 else:
                     return 0
 
-
     """
         else:
             if A.is_commutative:
@@ -1955,6 +1953,7 @@ def ReciprocalFrame(self, basis, mode='norm'):
     def Mlt(self,*args,**kwargs):
         return lt.Mlt(args[0], self, *args[1:], **kwargs)
 
+
 class Sm(Ga):
     """
     Submanifold is a geometric algebra defined on a submanifold of a
@@ -2011,7 +2010,7 @@ def __init__(self, __u, __coords, *, ga, norm=False, name=None, root='e', debug=
             Base Geometric Algebra
         """
 
-        #print '!!!Enter Sm!!!'
+        # print '!!!Enter Sm!!!'
 
         if printer.GaLatexPrinter.latex_flg:
             printer.GaLatexPrinter.restore()
@@ -2034,19 +2033,19 @@ def __init__(self, __u, __coords, *, ga, norm=False, name=None, root='e', debug=
         basis_str = basis_str[:-1]
         """
 
-        #print 'u =', u
+        # print 'u =', u
 
-        if isinstance(u,mv.Mv):  #Define vector manifold
+        if isinstance(u,mv.Mv):  # Define vector manifold
             self.ebasis = []
             for coord in coords:
-                #Partial derivation of vector function to get basis vectors
+                # Partial derivation of vector function to get basis vectors
                 self.ebasis.append(u.diff(coord))
 
-            #print 'sm ebasis =', self.ebasis
+            # print 'sm ebasis =', self.ebasis
 
             self.g = []
             for b1 in self.ebasis:
-                #Metric tensor from dot products of basis vectors
+                # Metric tensor from dot products of basis vectors
                 tmp = []
                 for b2 in self.ebasis:
                     tmp.append(b1 | b2)
@@ -2064,12 +2063,12 @@ def __init__(self, __u, __coords, *, ga, norm=False, name=None, root='e', debug=
                     tmp.append(diff(x_i, u_j))
                 dxdu.append(tmp)
 
-            #print 'dxdu =', dxdu
+            # print 'dxdu =', dxdu
 
             sub_pairs = list(zip(ga.coords, u))
 
-            #Construct metric tensor form coordinate maps
-            g = eye(n_sub)  #Zero n_sub x n_sub sympy matrix
+            # Construct metric tensor form coordinate maps
+            g = eye(n_sub)  # Zero n_sub x n_sub sympy matrix
             n_range = list(range(n_sub))
             for i in n_range:
                 for j in n_range:
@@ -2084,8 +2083,8 @@ def __init__(self, __u, __coords, *, ga, norm=False, name=None, root='e', debug=
 
         Ga.__init__(self, root, g=g, coords=coords, norm=norm, debug=debug)
 
-        if isinstance(u,mv.Mv):  #Construct additional functions for vector manifold
-            #self.r_basis_mv under construction
+        if isinstance(u,mv.Mv):  # Construct additional functions for vector manifold
+            # self.r_basis_mv under construction
 
             pass
 

galgebra/lt.py

@@ -2,7 +2,6 @@
 Multivector Linear Transformation
 """
 
-import sys
 import inspect
 import types
 import itertools
@@ -17,13 +16,15 @@
 from . import metric
 from . import mv
 
+
 def aprint(a):
     out = ''
     for ai in a:
         out += str(ai)+','
     print('['+out[:-1]+']')
     return
 
+
 def Symbolic_Matrix(root,coords=None,mode='g',f=False,sub=True):
     if sub:
         pos = '_'
@@ -95,6 +96,7 @@ def Matrix_to_dictionary(mat_rep,basis):
             dict_rep[basis[row]] += mat_rep[col,row]*basis[col]
     return dict_rep
 
+
 def Dictionary_to_Matrix(dict_rep, ga):
     """ Convert dictionary representation of linear transformation to matrix """
     basis = list(dict_rep.keys())
@@ -117,6 +119,7 @@ def Dictionary_to_Matrix(dict_rep, ga):
         lst_mat.append(lst_mat_row)
     return Transpose(Matrix(lst_mat))
 
+
 class Lt(object):
     r"""
     A Linear Transformation
@@ -151,7 +154,7 @@ class Lt(object):
 
     @staticmethod
     def setup(ga):
-        #coords = [Symbol('mu_' + str(x)) for x in ga.coords]
+        # coords = [Symbol('mu_' + str(x)) for x in ga.coords]
         coords = ga.coords
         x = sum([coords[i] * ga.basis[i] for i in ga.n_range])
         return coords, x
@@ -199,7 +202,7 @@ def __init__(self, *args, ga, f=False, mode='g'):
                 for (lt_i, base) in zip(mat_rep, self.Ga.basis):
                     self.lt_dict[base] = lt_i
             else:
-                #mat_rep = map(list, zip(*mat_rep))  # Transpose list of lists
+                # mat_rep = map(list, zip(*mat_rep))  # Transpose list of lists
                 for (row, base1) in zip(mat_rep, self.Ga.basis):
                     tmp = 0
                     for (col, base2) in zip(row, self.Ga.basis):
@@ -592,7 +595,7 @@ def Mlt_latex_str(self):
         expr_lst = Mlt.expand_expr(self.fvalue,self.Ga)
         latex_str = '\\begin{align*} '
         first = True
-        cnt = 1 #  Component count on line
+        cnt = 1  # Component count on line
         for term in expr_lst:
             coef_str = str(term[0])
             coef_latex = printer.latex(term[0])
@@ -610,15 +613,15 @@ def Mlt_latex_str(self):
                 latex_str += ' & ' + coef_latex
             else:
                 latex_str += coef_latex
-            if cnt%self.lcnt == 0:
+            if cnt % self.lcnt == 0:
                 latex_str += '\\\\ '
                 cnt = 1
             else:
                 cnt += 1
         if self.lcnt == len(expr_lst) or self.lcnt == 1:
             latex_str = latex_str[:-3]
         latex_str = latex_str + ' \\end{align*} \n'
-        return  latex_str
+        return latex_str
 
     def Fmt(self, lcnt=1, title=None):
         """
@@ -710,17 +713,17 @@ def __init__(self, f, Ga, args, fct=False):
         self.nargs = len(args)
         self.lcnt = 1
         if isinstance(f, mv.Mv):
-            if f.is_vector(): # f is vector T = f | a1
+            if f.is_vector():  # f is vector T = f | a1
                 if self.nargs != 1:
                     raise ValueError('For mlt nargs != 1 for vector!\n')
                 Ga.make_grad(self.args)
                 self.fvalue = (f | self.args[0]).obj
                 self.f = None
-            else: #  To be inplemented for f a general pure grade mulitvector
+            else:  # To be inplemented for f a general pure grade mulitvector
                 self.nargs = len(args)
                 self.fvalue = f
                 self.f = None
-        elif isinstance(f, Lt): #  f is linear transformation T = a1 | f(a2)
+        elif isinstance(f, Lt):  # f is linear transformation T = a1 | f(a2)
             if self.nargs != 2:
                 raise ValueError('For mlt nargs != 2 for linear transformation!\n')
             Ga.make_grad(self.args)
@@ -734,35 +737,35 @@ def __init__(self, f, Ga, args, fct=False):
             else:
                 self.args = [args]
                 self.nargs = 1
-            if self.nargs > 1: #  General tensor of rank > 1
+            if self.nargs > 1:  # General tensor of rank > 1
                 t_indexes = self.nargs * [Mlt.extact_basis_indexes(self.Ga)]
                 print(t_indexes)
                 print(self.Ga.Pdiffs)
                 self.fvalue = 0
                 for (t_index,a_prod) in zip(itertools.product(*t_indexes),
                                             itertools.product(*self.Ga.Pdiffs)):
-                    if fct: #  Tensor field
+                    if fct:  # Tensor field
                         coef = Function(f+'_'+''.join(map(str,t_index)),real=True)(*self.Ga.coords)
-                    else: #  Constant Tensor
+                    else:  # Constant Tensor
                         coef = symbols(f+'_'+''.join(map(str,t_index)),real=True)
                     coef *= reduce(lambda x, y: x*y, a_prod)
                     self.fvalue += coef
-            else: #  General tensor of rank = 1
+            else:  # General tensor of rank = 1
                 self.fvalue = 0
                 for (t_index,a_prod) in zip(Mlt.extact_basis_indexes(self.Ga),self.Ga.pdiffs[0]):
-                    if fct: #  Tensor field
+                    if fct:  # Tensor field
                         coef = Function(f+'_'+''.join(map(str,t_index)),real=True)(*self.Ga.coords)
-                    else: #  Constant Tensor
+                    else:  # Constant Tensor
                         coef = symbols(f+'_'+''.join(map(str,t_index)),real=True)
                     self.fvalue += coef * a_prod
         else:
-            if isinstance(f, types.FunctionType): #  Tensor defined by general multi-linear function
+            if isinstance(f, types.FunctionType):  # Tensor defined by general multi-linear function
                 args, _varargs, _kwargs, _defaults = inspect.getargspec(f)
                 self.nargs = len(args)
                 self.f = f
                 Mlt.increment_slots(self.nargs, Ga)
                 self.fvalue = f(*tuple(Ga.a[0:self.nargs]))
-            else: # Tensor defined by component expression
+            else:  # Tensor defined by component expression
                 self.f = None
                 self.nargs = len(args)
                 Mlt.increment_slots(self.nargs, Ga)
@@ -897,6 +900,7 @@ def comps(self):
         indexes = itertools.product(basis, repeat=rank)
         output = ''
         for i, (e, i_index) in enumerate(zip(indexes, i_indexes)):
-            if i_index[-1] % ndim == 0: print('')
+            if i_index[-1] % ndim == 0:
+                print('')
             output += str(i)+':'+str(i_index)+':'+str(self(*e)) + '\n'
         return output