gh-41662: partial cython-lint cleanup in matrix/
    
mostly cosmetic pep8 details, as suggested by cython-lint

### 📝 Checklist

- [x] The title is concise and informative.
- [x] The description explains in detail what this PR is about.
    
URL: #41662
Reported by: Frédéric Chapoton
Reviewer(s): David Coudert

Author: Release Manager

src/sage/matrix/action.pyx

@@ -211,9 +211,9 @@ cdef class MatrixMatrixAction(MatrixMulAction):
         """
         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())
+                           sparse=self.G.is_sparse() and self.underlying_set().is_sparse())
 
     cpdef _act_(self, g, s):
         """
@@ -321,7 +321,7 @@ cdef class MatrixVectorAction(MatrixMulAction):
         """
         if self.G.ncols() != self.underlying_set().degree():
             raise TypeError("incompatible dimensions %s, %s" % (self.G.ncols(),
-                                                                 self.underlying_set().degree()))
+                                                                self.underlying_set().degree()))
         return FreeModule(base, self.G.nrows(), sparse = self.G.is_sparse())
 
     cpdef _act_(self, g, s):
@@ -373,7 +373,7 @@ cdef class VectorMatrixAction(MatrixMulAction):
         """
         if self.G.nrows() != self.underlying_set().degree():
             raise TypeError("incompatible dimensions %s, %s" % (self.G.nrows(),
-                                                                 self.underlying_set().degree()))
+                                                                self.underlying_set().degree()))
         return FreeModule(base, self.G.ncols(), sparse = self.G.is_sparse())
 
     cpdef _act_(self, g, s):
@@ -388,7 +388,7 @@ cdef class VectorMatrixAction(MatrixMulAction):
                 v = v.sparse_vector()
             else:
                 v = v.dense_vector()
-        return (<Matrix>A)._vector_times_matrix_(v) # v * A
+        return (<Matrix>A)._vector_times_matrix_(v)  # v * A
 
 cdef class MatrixPolymapAction(MatrixMulAction):
     """
@@ -484,7 +484,7 @@ cdef class PolymapMatrixAction(MatrixMulAction):
         """
         if not isinstance(S, SchemeHomset_generic):
             raise TypeError("not a scheme polynomial morphism: %s"% S)
-        MatrixMulAction.__init__(self, G, S, False  )
+        MatrixMulAction.__init__(self, G, S, False)
 
     def _create_codomain(self, base):
         """
@@ -571,8 +571,8 @@ cdef class MatrixSchemePointAction(MatrixMulAction):
             sage: A.codomain()
             Set of rational points of Projective Space of dimension 1 over Rational Field
         """
-        #need to extend the base of the ambient space
-        #and return the set of point over the base
+        # need to extend the base of the ambient space
+        # and return the set of point over the base
         amb = self.underlying_set().codomain()
         return amb.change_ring(base)(base)
 

src/sage/matrix/args.pyx

@@ -4,15 +4,15 @@
 Helpers for creating matrices
 """
 
-#*****************************************************************************
+# ***************************************************************************
 #       Copyright (C) 2018 Jeroen Demeyer <J.Demeyer@UGent.be>
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 2 of the License, or
 # (at your option) any later version.
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ***************************************************************************
 
 cimport cython
 from cpython.sequence cimport PySequence_Fast
@@ -23,7 +23,7 @@ MatrixSpace = None
 from sage.rings.integer_ring import ZZ
 from sage.rings.integer cimport Integer
 from sage.structure.coerce cimport (coercion_model,
-        is_numpy_type, py_scalar_parent)
+                                    is_numpy_type, py_scalar_parent)
 from sage.structure.element cimport Element, RingElement, Vector
 from sage.arith.long cimport pyobject_to_long
 from sage.misc.misc_c import sized_iter
@@ -375,7 +375,8 @@ cdef class MatrixArgs:
         # Parse positional arguments (base, nrows, ncols, entries)
         # where each of them is optional.
         cdef Py_ssize_t argi = 0, argc = len(args)
-        if argi == argc: return
+        if argi == argc:
+            return
 
         # fast check for certain types of entries which cannot be
         # confused with a base ring or a number.
@@ -424,7 +425,8 @@ cdef class MatrixArgs:
         if self.entries is None:
             self.entries = args[argi]
             argi += 1
-            if argi == argc: return
+            if argi == argc:
+                return
 
         raise TypeError("too many arguments in matrix constructor")
 

src/sage/matrix/benchmark.py

@@ -157,7 +157,7 @@ def nullspace_ZZ(n=200, min=0, max=2**32, system='sage'):
 t := Cputime();
 K := Kernel(A);
 s := Cputime(t);
-""" % (n,min,max)
+""" % (n, min, max)
         if verbose:
             print(code)
         magma.eval(code)
@@ -197,7 +197,7 @@ def charpoly_ZZ(n=100, min=0, max=9, system='sage'):
 t := Cputime();
 K := CharacteristicPolynomial(A);
 s := Cputime(t);
-""" % (n,min,max)
+""" % (n, min, max)
         if verbose:
             print(code)
         magma.eval(code)
@@ -237,7 +237,7 @@ def rank_ZZ(n=700, min=0, max=9, system='sage'):
 t := Cputime();
 K := Rank(A);
 s := Cputime(t);
-""" % (n,min,max)
+""" % (n, min, max)
         if verbose:
             print(code)
         magma.eval(code)
@@ -277,7 +277,7 @@ def rank2_ZZ(n=400, min=0, max=2**64, system='sage'):
 t := Cputime();
 K := Rank(A);
 s := Cputime(t);
-""" % (n,min,max)
+""" % (n, min, max)
         if verbose:
             print(code)
         magma.eval(code)
@@ -319,7 +319,7 @@ def smithform_ZZ(n=128, min=0, max=9, system='sage'):
 t := Cputime();
 K := ElementaryDivisors(A);
 s := Cputime(t);
-""" % (n,min,max)
+""" % (n, min, max)
         if verbose:
             print(code)
         magma.eval(code)
@@ -365,7 +365,7 @@ def matrix_multiply_ZZ(n=300, min=-9, max=9, system='sage', times=1):
     K := A * B;
 end for;
 s := Cputime(t);
-""" % (n,min,max,times)
+""" % (n, min, max, times)
         if verbose:
             print(code)
         magma.eval(code)
@@ -413,7 +413,7 @@ def matrix_add_ZZ(n=200, min=-9, max=9, system='sage', times=50):
     K := A + B;
 end for;
 s := Cputime(t);
-""" % (n,min,max,times)
+""" % (n, min, max, times)
         if verbose:
             print(code)
         magma.eval(code)
@@ -476,7 +476,7 @@ def det_ZZ(n=200, min=1, max=100, system='sage'):
 t := Cputime();
 d := Determinant(A);
 s := Cputime(t);
-""" % (n,min,max)
+""" % (n, min, max)
         if verbose:
             print(code)
         magma.eval(code)
@@ -565,7 +565,7 @@ def vecmat_ZZ(n=300, min=-9, max=9, system='sage', times=200):
     K := v * A;
 end for;
 s := Cputime(t);
-""" % (n,min,max,times)
+""" % (n, min, max, times)
         if verbose:
             print(code)
         magma.eval(code)
@@ -950,7 +950,7 @@ def echelon_QQ(n=100, min=0, max=9, system='sage'):
 t := Cputime();
 K := EchelonForm(A);
 s := Cputime(t);
-""" % (n,min,max)
+""" % (n, min, max)
         if verbose:
             print(code)
         magma.eval(code)
@@ -991,7 +991,7 @@ def inverse_QQ(n=100, min=0, max=9, system='sage'):
 t := Cputime();
 K := A^(-1);
 s := Cputime(t);
-""" % (n,min,max)
+""" % (n, min, max)
         if verbose:
             print(code)
         magma.eval(code)
@@ -1207,7 +1207,7 @@ def nullspace_RR(n=300, min=0, max=10, system='sage'):
 t := Cputime();
 K := Kernel(A);
 s := Cputime(t);
-""" % (n,min,max)
+""" % (n, min, max)
         if verbose:
             print(code)
         magma.eval(code)

src/sage/matrix/constructor.pyx

@@ -2,7 +2,7 @@
 General matrix Constructor and display options
 """
 
-#*****************************************************************************
+# ***************************************************************************
 #       Copyright (C) 2005 William Stein <wstein@gmail.com>
 #       Copyright (C) 2016 Jeroen Demeyer <J.Demeyer@UGent.be>
 #
@@ -11,7 +11,7 @@ General matrix Constructor and display options
 # the Free Software Foundation, either version 2 of the License, or
 # (at your option) any later version.
 #                  http://www.gnu.org/licenses/
-#*****************************************************************************
+# ***************************************************************************
 
 from sage.matrix.args cimport MatrixArgs
 from sage.structure.global_options import GlobalOptions

src/sage/matrix/echelon_matrix.pyx

@@ -105,33 +105,33 @@ def reduced_echelon_matrix_iterator(K, k, n, bint sparse=False, bint copy=True,
         sage: all(a.is_immutable() and a.echelon_form() == a for a in it)
         True
     """
-    cdef Matrix m0,m,mm
+    cdef Matrix m0, m, mm
     cdef Py_ssize_t i
     n = int(n)
     k = int(k)
 
     if n < k:
         raise NotImplementedError("echelon matrix with fewer rows than columns "
-                "i.e. not full rank) are not implemented")
+                                  "i.e. not full rank) are not implemented")
 
     from sage.matrix.matrix_space import MatrixSpace
-    from itertools import combinations,product
+    from itertools import combinations, product
 
     copy = copy or set_immutable
 
-    m0 = MatrixSpace(K,k,n,sparse=sparse)()
+    m0 = MatrixSpace(K, k, n, sparse=sparse)()
     Klist = list(K)
     K1 = K.one()
 
     # First, we select which columns will be pivots:
-    for pivots in combinations(range(n),k):
+    for pivots in combinations(range(n), k):
         m = m0.__copy__()
         free_positions = []
         for i in range(k):
-            m[i,pivots[i]] = K1
-            for j in range(pivots[i]+1,n):
+            m[i, pivots[i]] = K1
+            for j in range(pivots[i]+1, n):
                 if j not in pivots:
-                    free_positions.append((i,j))
+                    free_positions.append((i, j))
 
         # Next, we fill in those entries that are not
         # determined by the echelon form alone:
@@ -142,9 +142,9 @@ def reduced_echelon_matrix_iterator(K, k, n, bint sparse=False, bint copy=True,
 
             if copy:
                 mm = m.__copy__()
-                mm.cache('pivots',pivots)
-                mm.cache('rank',k)
-                mm.cache('in_echelon_form',True)
+                mm.cache('pivots', pivots)
+                mm.cache('rank', k)
+                mm.cache('in_echelon_form', True)
                 if set_immutable:
                     mm.set_immutable()
                 yield mm

src/sage/matrix/matrix_cyclo_dense.pxd

@@ -11,5 +11,6 @@ cdef class Matrix_cyclo_dense(Matrix_dense):
     cdef int _degree
     cdef int _n
 
-    cdef _randomize_rational_column_unsafe(Matrix_cyclo_dense self,
+    cdef _randomize_rational_column_unsafe(
+        Matrix_cyclo_dense self,
         Py_ssize_t col, mpz_t nump1, mpz_t denp1, distribution=?)

src/sage/matrix/matrix_double_sparse.pyx

@@ -176,7 +176,7 @@ cdef class Matrix_double_sparse(Matrix_generic_sparse):
             sage: (B.cholesky() - L).norm(1) < 1e-10                                    # needs scipy
             True
         """
-        cdef Matrix L # output matrix
+        cdef Matrix L  # output matrix
 
         L = self.fetch('cholesky')
         if L is not None:

src/sage/matrix/matrix_generic_sparse.pyx

@@ -191,14 +191,14 @@ cdef class Matrix_generic_sparse(matrix_sparse.Matrix_sparse):
     cdef set_unsafe(self, Py_ssize_t i, Py_ssize_t j, value):
         if not value:
             try:
-                del self._entries[(i,j)]
+                del self._entries[(i, j)]
             except KeyError:
                 pass
         else:
-            self._entries[(i,j)] = value
+            self._entries[(i, j)] = value
 
     cdef get_unsafe(self, Py_ssize_t i, Py_ssize_t j):
-        return self._entries.get((i,j), self._zero)
+        return self._entries.get((i, j), self._zero)
 
     cdef copy_from_unsafe(self, Py_ssize_t iDst, Py_ssize_t jDst, src, Py_ssize_t iSrc, Py_ssize_t jSrc):
         r"""
@@ -239,10 +239,10 @@ cdef class Matrix_generic_sparse(matrix_sparse.Matrix_sparse):
             [      0       2]
         """
         cdef Matrix_generic_sparse _src = <Matrix_generic_sparse>src
-        if (iSrc,jSrc) in _src._entries:
-            self._entries[(iDst,jDst)] = _src._entries.get((iSrc, jSrc), _src._zero)
-        elif (iDst,jDst) in self._entries:
-            del self._entries[(iDst,jDst)]
+        if (iSrc, jSrc) in _src._entries:
+            self._entries[(iDst, jDst)] = _src._entries.get((iSrc, jSrc), _src._zero)
+        elif (iDst, jDst) in self._entries:
+            del self._entries[(iDst, jDst)]
 
     cdef bint get_is_zero_unsafe(self, Py_ssize_t i, Py_ssize_t j) except -1:
         """
@@ -256,7 +256,7 @@ cdef class Matrix_generic_sparse(matrix_sparse.Matrix_sparse):
             [0 1 1 1]
             [1 1 1 0]
         """
-        return (i,j) not in self._entries
+        return (i, j) not in self._entries
 
     def _pickle(self):
         version = 0
@@ -392,11 +392,11 @@ cdef class Matrix_generic_sparse(matrix_sparse.Matrix_sparse):
         Return all entries of ``self`` as a list of numbers of rows times
         number of columns entries.
         """
-        cdef Py_ssize_t i,j
+        cdef Py_ssize_t i, j
         cdef list v = self.fetch('list')
         if v is None:
             v = [self._zero]*(self._nrows * self._ncols)
-            for (i,j), x in self._entries.items():
+            for (i, j), x in self._entries.items():
                 v[i*self._ncols + j] = x
             self.cache('list', v)
         return v

src/sage/matrix/matrix_integer_dense.pxd

@@ -24,9 +24,9 @@ cdef class Matrix_integer_dense(Matrix_dense):
 
     # HNF Modn
     cdef int _hnf_modn(Matrix_integer_dense self, Matrix_integer_dense res,
-            unsigned int det) except -1
+                       unsigned int det) except -1
     cdef int* _hnf_modn_impl(Matrix_integer_dense self, unsigned int det,
-            Py_ssize_t nrows, Py_ssize_t ncols) except NULL
+                             Py_ssize_t nrows, Py_ssize_t ncols) except NULL
 
     cdef Matrix_integer_dense _new(self, Py_ssize_t nrows, Py_ssize_t ncols)
 

src/sage/matrix/matrix_modn_dense_double.pyx

@@ -216,4 +216,3 @@ cdef class Matrix_modn_dense_double(Matrix_modn_dense_template):
         """
         cdef Matrix_modn_dense_double _src = <Matrix_modn_dense_double>src
         self._matrix[iDst][jDst] = _src._matrix[iSrc][jSrc]
-