some care for pep8 code E241 in some pyx files

Author: fchapoton

src/sage/coding/codecan/codecan.pyx

@@ -920,8 +920,8 @@ cdef class PartitionRefinementLinearCode(PartitionRefinement_generic):
         if self._inner_group.rank < 2:
             return True
 
-        lower = iter(self._matrix[ : self._inner_group.rank  ].columns())
-        upper = iter(self._matrix[ self._inner_group.rank :  ].columns())
+        lower = iter(self._matrix[ : self._inner_group.rank].columns())
+        upper = iter(self._matrix[self._inner_group.rank : ].columns())
 
         for i in range(self._n):
             l = next(lower)

src/sage/combinat/crystals/tensor_product_element.pyx

@@ -1867,4 +1867,4 @@ cdef Py_ssize_t count_leading(list row, letter) noexcept:
 
 # for unpickling
 from sage.misc.persist import register_unpickle_override
-register_unpickle_override('sage.combinat.crystals.tensor_product', 'ImmutableListWithParent',  ImmutableListWithParent)
+register_unpickle_override('sage.combinat.crystals.tensor_product', 'ImmutableListWithParent', ImmutableListWithParent)

src/sage/combinat/designs/orthogonal_arrays_find_recursive.pyx

@@ -755,46 +755,45 @@ cpdef find_brouwer_separable_design(int k,int n) noexcept:
 
             # i)
             if (x == 0 and
-                is_available(k, t)  and
-                is_available(k,t+q)):
-                return brouwer_separable_design, (k,t,q,x)
+                is_available(k, t) and is_available(k, t+q)):
+                return brouwer_separable_design, (k, t, q, x)
 
             # ii)
             elif (x == t+q and
-                  is_available(k+e3,  t  ) and
-                  is_available(  k , t+q ) and
+                  is_available(k+e3, t) and
+                  is_available(k, t+q) and
                   is_available(k+1 ,t+q+1)):
-                return brouwer_separable_design, (k,t,q,x)
+                return brouwer_separable_design, (k, t, q, x)
 
             # iii)
             elif (x == q**2-q+1-t and
-                  is_available(  k  ,  x  ) and
-                  is_available( k+e2, t+1 ) and
-                  is_available( k+1 , t+q )):
-                return brouwer_separable_design, (k,t,q,x)
+                  is_available(k, x) and
+                  is_available(k+e2, t+1)
+                  and is_available(k+1, t+q)):
+                return brouwer_separable_design, (k, t, q, x)
 
             # iv)
             elif (x == q**2+1 and
-                  is_available(  k  ,  x  ) and
-                  is_available( k+e4, t+1 ) and
-                  is_available( k+1 ,t+q+1)):
-                return brouwer_separable_design, (k,t,q,x)
+                  is_available(k, x) and
+                  is_available(k+e4, t+1) and
+                  is_available(k+1 ,t+q+1)):
+                return brouwer_separable_design, (k, t, q, x)
 
             # v)
             elif (0<x and x<q**2-q+1-t and (e1 or e2) and
-                  is_available(  k  ,  x  ) and
-                  is_available( k+e1,  t  ) and
-                  is_available( k+e2, t+1 ) and
-                  is_available( k+1 , t+q )):
-                return brouwer_separable_design, (k,t,q,x)
+                  is_available(k, x) and
+                  is_available(k+e1, t) and
+                  is_available(k+e2, t+1) and
+                  is_available(k+1, t+q)):
+                return brouwer_separable_design, (k, t, q, x)
 
             # vi)
             elif (t+q<x and x<q**2+1 and (e3 or e4) and
-                  is_available(  k  ,  x  ) and
-                  is_available( k+e3,  t  ) and
-                  is_available( k+e4, t+1 ) and
-                  is_available( k+1 ,t+q+1)):
-                return brouwer_separable_design, (k,t,q,x)
+                  is_available(k, x) and
+                  is_available(k+e3, t) and
+                  is_available(k+e4, t+1) and
+                  is_available(k+1, t+q+1)):
+                return brouwer_separable_design, (k, t, q, x)
 
     return False
 
@@ -808,7 +807,7 @@ for x in _QDM.itervalues():
         if u>1:
             if n not in ioa_indexed_by_n_minus_x:
                 ioa_indexed_by_n_minus_x[n] = []
-            ioa_indexed_by_n_minus_x[n].append((k,u))
+            ioa_indexed_by_n_minus_x[n].append((k, u))
 
 
 def int_as_sum(int value, list S, int k_max):

src/sage/groups/perm_gps/partn_ref/data_structures.pyx

@@ -629,12 +629,12 @@ cdef inline int SC_realloc_gens(StabilizerChain *SC, int level, int size) noexce
     cdef int *temp
     cdef int n = SC.degree
 
-    temp = <int *> sig_realloc( SC.generators[level],   n * size * sizeof(int) )
+    temp = <int *> sig_realloc(SC.generators[level], n * size * sizeof(int))
     if temp is NULL:
         return 1
     SC.generators[level] = temp
 
-    temp = <int *> sig_realloc( SC.gen_inverses[level], n * size * sizeof(int) )
+    temp = <int *> sig_realloc(SC.gen_inverses[level], n * size * sizeof(int))
     if temp is NULL:
         return 1
     SC.gen_inverses[level] = temp

src/sage/groups/perm_gps/partn_ref/double_coset.pyx

@@ -400,14 +400,14 @@ cdef int double_coset(void *S1, void *S2, PartitionStack *partition1, int *order
     cdef bint unknown = 1
 
     # set up the identity permutation
-    for i from 0 <= i < n:
+    for i in range(n):
         id_perm[i] = i
     if ordering2 is NULL:
         ordering2 = id_perm
 
     # Copy reordering of left_ps coming from ordering2 to current_ps.
-    memcpy(current_ps.entries, ordering2,      n*sizeof(int))
-    memcpy(current_ps.levels,  left_ps.levels, n*sizeof(int))
+    memcpy(current_ps.entries, ordering2, n * sizeof(int))
+    memcpy(current_ps.levels, left_ps.levels, n * sizeof(int))
     current_ps.depth = left_ps.depth
 
     # default values of "infinity"

src/sage/matrix/action.pyx

@@ -195,11 +195,10 @@ cdef class MatrixMatrixAction(MatrixMulAction):
             Nonetheless, there is no guarantee that the set that is acted upon
             will always be cached in such a way, so that following the above
             example is good practice.
-
         """
         if self.G.ncols() != self.underlying_set().nrows():
             raise TypeError("incompatible dimensions %s, %s" %
-                    (self.G.ncols(),  self.underlying_set().nrows()))
+                    (self.G.ncols(), self.underlying_set().nrows()))
         return MatrixSpace(base, self.G.nrows(), self.underlying_set().ncols(),
                            sparse = self.G.is_sparse() and self.underlying_set().is_sparse())
 

src/sage/matrix/matrix0.pyx

@@ -2350,7 +2350,7 @@ cdef class Matrix(sage.structure.element.Matrix):
         for i from 0 <= i < n:
             tmp = []
             for j from 0 <= j < n:
-                tmp.append(self.get_unsafe(i,j)*vars[j])
+                tmp.append(self.get_unsafe(i, j)*vars[j])
             ans.append( sum(tmp) )
         return f(tuple(ans))
 
@@ -2912,7 +2912,7 @@ cdef class Matrix(sage.structure.element.Matrix):
         """
         return self.with_permuted_rows(row_permutation).with_permuted_columns(column_permutation)
 
-    def add_multiple_of_row(self, Py_ssize_t i, Py_ssize_t j,    s,   Py_ssize_t start_col=0):
+    def add_multiple_of_row(self, Py_ssize_t i, Py_ssize_t j, s, Py_ssize_t start_col=0):
         """
         Add s times row j to row i.
 
@@ -2943,19 +2943,19 @@ cdef class Matrix(sage.structure.element.Matrix):
             TypeError: Multiplying row by Symbolic Ring element cannot be done over
             Rational Field, use change_ring or with_added_multiple_of_row instead.
         """
-        self.check_row_bounds_and_mutability(i,j)
+        self.check_row_bounds_and_mutability(i, j)
         try:
             s = self._coerce_element(s)
             self.add_multiple_of_row_c(i, j, s, start_col)
         except TypeError:
             raise TypeError('Multiplying row by %s element cannot be done over %s, use change_ring or with_added_multiple_of_row instead.' % (s.parent(), self.base_ring()))
 
-    cdef add_multiple_of_row_c(self, Py_ssize_t i, Py_ssize_t j,    s,   Py_ssize_t start_col) noexcept:
+    cdef add_multiple_of_row_c(self, Py_ssize_t i, Py_ssize_t j, s, Py_ssize_t start_col) noexcept:
         cdef Py_ssize_t c
         for c from start_col <= c < self._ncols:
             self.set_unsafe(i, c, self.get_unsafe(i, c) + s*self.get_unsafe(j, c))
 
-    def with_added_multiple_of_row(self, Py_ssize_t i, Py_ssize_t j,    s,   Py_ssize_t start_col=0):
+    def with_added_multiple_of_row(self, Py_ssize_t i, Py_ssize_t j, s, Py_ssize_t start_col=0):
         """
         Add s times row j to row i, returning new matrix.
 
@@ -2983,7 +2983,7 @@ cdef class Matrix(sage.structure.element.Matrix):
             [   3    4    5]
         """
         cdef Matrix temp
-        self.check_row_bounds_and_mutability(i,j)
+        self.check_row_bounds_and_mutability(i, j)
         try:
             s = self._coerce_element(s)
             temp = self.__copy__()
@@ -3028,7 +3028,7 @@ cdef class Matrix(sage.structure.element.Matrix):
             TypeError: Multiplying column by Symbolic Ring element cannot be done over
             Rational Field, use change_ring or with_added_multiple_of_column instead.
         """
-        self.check_column_bounds_and_mutability(i,j)
+        self.check_column_bounds_and_mutability(i, j)
         try:
             s = self._coerce_element(s)
             self.add_multiple_of_column_c(i, j, s, start_row)
@@ -3040,7 +3040,7 @@ cdef class Matrix(sage.structure.element.Matrix):
         for r from start_row <= r < self._nrows:
             self.set_unsafe(r, i, self.get_unsafe(r, i) + s*self.get_unsafe(r, j))
 
-    def with_added_multiple_of_column(self, Py_ssize_t i, Py_ssize_t j,    s,   Py_ssize_t start_row=0):
+    def with_added_multiple_of_column(self, Py_ssize_t i, Py_ssize_t j, s, Py_ssize_t start_row=0):
         """
         Add s times column j to column i, returning new matrix.
 
@@ -3068,7 +3068,7 @@ cdef class Matrix(sage.structure.element.Matrix):
             [13/3    4    5]
         """
         cdef Matrix temp
-        self.check_column_bounds_and_mutability(i,j)
+        self.check_column_bounds_and_mutability(i, j)
         try:
             s = self._coerce_element(s)
             temp = self.__copy__()
@@ -3335,7 +3335,7 @@ cdef class Matrix(sage.structure.element.Matrix):
             ...
             TypeError: Multiplying row by Rational Field element cannot be done over Integer Ring, use change_ring or with_row_set_to_multiple_of_row instead.
         """
-        self.check_row_bounds_and_mutability(i,j)
+        self.check_row_bounds_and_mutability(i, j)
         cdef Py_ssize_t n
         try:
             s = self._coerce_element(s)
@@ -3370,7 +3370,7 @@ cdef class Matrix(sage.structure.element.Matrix):
             [  0   1   2]
             [  0 1/2   1]
         """
-        self.check_row_bounds_and_mutability(i,j)
+        self.check_row_bounds_and_mutability(i, j)
         cdef Matrix temp
         cdef Py_ssize_t n
         try:
@@ -3413,7 +3413,7 @@ cdef class Matrix(sage.structure.element.Matrix):
             ...
             TypeError: Multiplying column by Rational Field element cannot be done over Integer Ring, use change_ring or with_col_set_to_multiple_of_col instead.
         """
-        self.check_column_bounds_and_mutability(i,j)
+        self.check_column_bounds_and_mutability(i, j)
         cdef Py_ssize_t n
         try:
             s = self._coerce_element(s)
@@ -3453,7 +3453,7 @@ cdef class Matrix(sage.structure.element.Matrix):
             [  0   0   2]
             [  3 3/2   5]
         """
-        self.check_column_bounds_and_mutability(i,j)
+        self.check_column_bounds_and_mutability(i, j)
         cdef Py_ssize_t n
         cdef Matrix temp
         try:
@@ -3706,7 +3706,7 @@ cdef class Matrix(sage.structure.element.Matrix):
                     if positive and not d[i] > 0:
                         return False
                     for j in d:
-                        if d[i] * self.get_unsafe(i,j) != sign * d[j] * self.get_unsafe(j,i):
+                        if d[i] * self.get_unsafe(i, j) != sign * d[j] * self.get_unsafe(j,i):
                             return False
         return L
 
@@ -3959,11 +3959,11 @@ cdef class Matrix(sage.structure.element.Matrix):
         if self._ncols != self._nrows: return False
         # could be bigger than an int on a 64-bit platform, this
         #  is the type used for indexing.
-        cdef Py_ssize_t i,j
+        cdef Py_ssize_t i, j
 
         for i from 0 <= i < self._nrows:
             for j from 0 <= j < i:
-                if self.get_unsafe(i,j) != self.get_unsafe(j,i):
+                if self.get_unsafe(i, j) != self.get_unsafe(j, i):
                     return False
         return True
 
@@ -4072,7 +4072,7 @@ cdef class Matrix(sage.structure.element.Matrix):
 
         tolerance = self.base_ring()(tolerance)
         cdef bint tolerance_is_zero = tolerance.is_zero()
-        cdef Py_ssize_t i,j
+        cdef Py_ssize_t i, j
 
         if self.is_sparse_c():
             # The dense algorithm checks all of the on-or-below-diagonal
@@ -4086,12 +4086,12 @@ cdef class Matrix(sage.structure.element.Matrix):
             # copy, so it's important that we don't modify it.
             entries = self._nonzero_positions_by_row(copy=False)
         else:
-            entries = ( (i,j) for i in range(self._nrows)
-                              for j in range(i+1) )
+            entries = ((i, j) for i in range(self._nrows)
+                       for j in range(i + 1))
 
-        for (i,j) in entries:
-            entry_a = self.get_unsafe(i,j)
-            entry_b = s*self.get_unsafe(j,i).conjugate()
+        for (i, j) in entries:
+            entry_a = self.get_unsafe(i, j)
+            entry_b = s*self.get_unsafe(j, i).conjugate()
 
             if tolerance_is_zero:
                 # When the tolerance is exactly zero, as will
@@ -4293,11 +4293,11 @@ cdef class Matrix(sage.structure.element.Matrix):
         if self._ncols != self._nrows: return False
         # could be bigger than an int on a 64-bit platform, this
         #  is the type used for indexing.
-        cdef Py_ssize_t i,j
+        cdef Py_ssize_t i, j
 
         for i from 0 <= i < self._nrows:
             for j from 0 <= j <= i:
-                if self.get_unsafe(i,j) != -self.get_unsafe(j,i):
+                if self.get_unsafe(i, j) != -self.get_unsafe(j,i):
                     return False
         return True
 
@@ -4336,14 +4336,14 @@ cdef class Matrix(sage.structure.element.Matrix):
         if self._ncols != self._nrows: return False
         # could be bigger than an int on a 64-bit platform, this
         #  is the type used for indexing.
-        cdef Py_ssize_t i,j
+        cdef Py_ssize_t i, j
 
         zero = self._base_ring.zero()
         for i from 0 <= i < self._nrows:
             for j from 0 <= j < i:
-                if self.get_unsafe(i,j) != -self.get_unsafe(j,i):
+                if self.get_unsafe(i, j) != -self.get_unsafe(j, i):
                     return False
-            if not self.get_unsafe(i,i) == zero:
+            if not self.get_unsafe(i, i) == zero:
                 return False
         return True
 
@@ -4803,8 +4803,8 @@ cdef class Matrix(sage.structure.element.Matrix):
         nzp = []
         for j from 0 <= j < self._ncols:
             for i from 0 <= i < self._nrows:
-                if not self.get_is_zero_unsafe(i,j):
-                    nzp.append((i,j))
+                if not self.get_is_zero_unsafe(i, j):
+                    nzp.append((i, j))
         self.cache('nonzero_positions_by_column', nzp)
         if copy:
             return list(nzp)
@@ -4882,7 +4882,7 @@ cdef class Matrix(sage.structure.element.Matrix):
         tmp = []
 
         for j from 0 <= j < self._ncols:
-            if not self.get_is_zero_unsafe(i,j):
+            if not self.get_is_zero_unsafe(i, j):
                 tmp.append(j)
         return tmp
 
@@ -5227,7 +5227,7 @@ cdef class Matrix(sage.structure.element.Matrix):
         A = self.new_matrix()
         for i in range(self._nrows):
             for j in range(self._ncols):
-                A.set_unsafe(i,j,self.get_unsafe(i,j)._add_(right.get_unsafe(i,j)))
+                A.set_unsafe(i, j, self.get_unsafe(i,j)._add_(right.get_unsafe(i,j)))
         return A
 
     cpdef _sub_(self, _right) noexcept:

src/sage/matrix/matrix_cyclo_dense.pyx

@@ -661,7 +661,7 @@ cdef class Matrix_cyclo_dense(Matrix_dense):
             prod *= p
             Amodp, _ = self._reductions(p)
             Bmodp, _ = right._reductions(p)
-            _,     S = self._reduction_matrix(p)
+            _, S = self._reduction_matrix(p)
             X = Amodp[0]._matrix_from_rows_of_matrices([Amodp[i] * Bmodp[i] for i in range(len(Amodp))])
             v.append(S*X)
             p = previous_prime(p)

src/sage/matrix/matrix_gf2e_dense.pyx

@@ -1033,8 +1033,7 @@ cdef class Matrix_gf2e_dense(matrix_dense.Matrix_dense):
         cdef m4ri_word x = poly_to_word(multiple)
         mzed_rescale_row(self._entries, row, start_col, x)
 
-
-    cdef add_multiple_of_row_c(self,  Py_ssize_t row_to, Py_ssize_t row_from, multiple, Py_ssize_t start_col) noexcept:
+    cdef add_multiple_of_row_c(self, Py_ssize_t row_to, Py_ssize_t row_from, multiple, Py_ssize_t start_col) noexcept:
         """
         Compute ``self[row_to][start_col:] += multiple * self[row_from][start_col:]``.
 

src/sage/matrix/matrix_gfpn_dense.pyx

@@ -1042,7 +1042,7 @@ cdef class Matrix_gfpn_dense(Matrix_dense):
             FfSetNoc(noc)
             FfMulRow(row_head, c)
 
-    cdef add_multiple_of_row_c(self,  Py_ssize_t row_to, Py_ssize_t row_from, multiple, Py_ssize_t start_col) noexcept:
+    cdef add_multiple_of_row_c(self, Py_ssize_t row_to, Py_ssize_t row_from, multiple, Py_ssize_t start_col) noexcept:
         """
         Add the ``multiple``-fold of row ``row_from`` in-place to row ``row_to``, beginning with ``start_col``