passagemath-flint 10.5.43__cp310-cp310-macosx_14_0_arm64.whl → 10.6.1rc1__cp310-cp310-macosx_14_0_arm64.whl

sage/libs/flint/nmod_poly_linkage.pxi

@@ -6,8 +6,9 @@ This file provides the backend for \class{Polynomial_zmod_flint} via
 templating.
 
 AUTHOR:
-    -- Martin Albrecht (2009-01) another initial implementation
-    -- Burcin Erocal (2008-11) initial implementation
+
+- Martin Albrecht (2009-01) another initial implementation
+- Burcin Erocal (2008-11) initial implementation
 """
 #*****************************************************************************
 #       Copyright (C) 2008-2009 Burcin Erocal <burcin@erocal.org>
@@ -15,7 +16,7 @@ AUTHOR:
 #
 #  Distributed under the terms of the GNU General Public License (GPL),
 #  version 2 or any later version.  The full text of the GPL is available at:
-#                  http://www.gnu.org/licenses/
+#                  https://www.gnu.org/licenses/
 #*****************************************************************************
 
 from cysignals.signals cimport sig_on, sig_off
@@ -338,7 +339,7 @@ cdef inline int celement_mul_scalar(nmod_poly_t res, nmod_poly_t p,
         sage: (p*9836).coefficients() == [x*9836 for x in p.coefficients()]
         True
     """
-    nmod_poly_scalar_mul_nmod(res, p, (<unsigned long>c)%n)
+    nmod_poly_scalar_mul_nmod(res, p, (<unsigned long>c) % n)
 
 cdef inline int celement_mul(nmod_poly_t res, nmod_poly_t a, nmod_poly_t b, unsigned long n) except -2:
     """

sage/libs/flint/types.pxd

@@ -267,9 +267,9 @@ cdef extern from "flint_wrap.h":
 
 
     # flint/flint.h
-    ctypedef struct flint_rand_s:
+    ctypedef struct flint_rand_struct:
         pass
-    ctypedef flint_rand_s flint_rand_t[1]
+    ctypedef flint_rand_struct flint_rand_t[1]
 
     cdef long FLINT_BITS
     cdef long FLINT_D_BITS

sage/matrix/matrix_cyclo_dense.pyx

@@ -1230,7 +1230,7 @@ cdef class Matrix_cyclo_dense(Matrix_dense):
             sage: Matrix(CyclotomicField(10),0).charpoly()
             1
         """
-        key = 'charpoly-%s-%s'%(algorithm,proof)
+        key = 'charpoly-%s-%s' % (algorithm, proof)
         f = self.fetch(key)
         if f is not None:
             return f.change_variable_name(var)
@@ -1525,7 +1525,7 @@ cdef class Matrix_cyclo_dense(Matrix_dense):
             sage: a == b  # long time (depends on previous)
             True
         """
-        key = 'echelon_form-%s'%algorithm
+        key = 'echelon_form-%s' % algorithm
         E = self.fetch(key)
         if E is not None:
             return E
@@ -1631,7 +1631,7 @@ cdef class Matrix_cyclo_dense(Matrix_dense):
             ...
             ValueError: echelon form mod 7 not defined
         """
-        cdef int i
+        cdef Py_ssize_t i
 
         # Initialize variables
         ls, _ = self._reductions(p)

sage/matrix/matrix_integer_dense.pyx

@@ -60,7 +60,7 @@ TESTS::
 from libc.stdint cimport int64_t
 from libc.string cimport strcpy, strlen
 
-from sage.cpython.string cimport char_to_str, str_to_bytes
+from sage.cpython.string cimport char_to_str
 from sage.ext.stdsage cimport PY_NEW
 from cysignals.signals cimport sig_check, sig_on, sig_str, sig_off
 from cysignals.memory cimport sig_malloc, sig_free, check_allocarray
@@ -446,7 +446,7 @@ cdef class Matrix_integer_dense(Matrix_dense):
             sage: matrix(ZZ,1,3,[1,193,15])._pickle() == (b'1 61 f', 0)   # indirect doctest
             True
         """
-        return str_to_bytes(self._export_as_string(32), 'ascii')
+        return self._export_as_string(32).encode('ascii')
 
     cpdef _export_as_string(self, int base=10):
         """
@@ -467,7 +467,8 @@ cdef class Matrix_integer_dense(Matrix_dense):
         """
         # TODO: *maybe* redo this to use mpz_import and mpz_export
         # from sec 5.14 of the GMP manual. ??
-        cdef int i, j, len_so_far, m, n
+        cdef Py_ssize_t i, j, len_so_far
+        cdef int m, n
         cdef char *s
         cdef char *t
         cdef char *tmp
@@ -530,18 +531,18 @@ cdef class Matrix_integer_dense(Matrix_dense):
                 self._unpickle_matrix_2x2_version0(data)
             else:
                 raise RuntimeError("invalid pickle data")
+
         else:
-            raise RuntimeError("unknown matrix version (=%s)"%version)
+            raise RuntimeError(f"unknown matrix version (={version})")
 
     cdef _unpickle_version0(self, data):
-        cdef Py_ssize_t i, j, n, k
+        cdef Py_ssize_t i, j, k
         data = data.split()
-        n = self._nrows * self._ncols
-        if len(data) != n:
+        if len(data) != self._nrows * self._ncols:
             raise RuntimeError("invalid pickle data")
         k = 0
-        for i from 0 <= i < self._nrows:
-            for j from 0 <= j < self._ncols:
+        for i in range(self._nrows):
+            for j in range(self._ncols):
                 s = data[k]
                 k += 1
                 if fmpz_set_str(fmpz_mat_entry(self._matrix, i, j), s, 32):
@@ -1321,7 +1322,7 @@ cdef class Matrix_integer_dense(Matrix_dense):
         elif algorithm == 'generic':
             g = Matrix_dense.charpoly(self, var)
         else:
-            raise ValueError("no algorithm '%s'"%algorithm)
+            raise ValueError("no algorithm '%s'" % algorithm)
 
         self.cache(cache_key, g)
         return g
@@ -1396,7 +1397,7 @@ cdef class Matrix_integer_dense(Matrix_dense):
             else:
                 algorithm = 'linbox'
 
-        key = 'minpoly_%s'%(algorithm)
+        key = 'minpoly_%s' % (algorithm)
         g = self.fetch(key)
         if g is not None:
             return g.change_variable_name(var)
@@ -1407,7 +1408,7 @@ cdef class Matrix_integer_dense(Matrix_dense):
         elif algorithm == 'generic':
             g = Matrix_dense.minpoly(self, var)
         else:
-            raise ValueError("no algorithm '%s'"%algorithm)
+            raise ValueError("no algorithm '%s'" % algorithm)
 
         self.cache(key, g)
         return g
@@ -1561,7 +1562,7 @@ cdef class Matrix_integer_dense(Matrix_dense):
             [  1  -2 -45]
         """
         w = self._export_as_string(base=10)
-        return 'Matrix(IntegerRing(),%s,%s,StringToIntegerSequence("%s"))'%(
+        return 'Matrix(IntegerRing(),%s,%s,StringToIntegerSequence("%s"))' % (
             self.nrows(), self.ncols(), w)
 
     def symplectic_form(self):
@@ -1864,7 +1865,7 @@ cdef class Matrix_integer_dense(Matrix_dense):
             sage: H == U*m
             True
         """
-        key = 'hnf-%s-%s'%(include_zero_rows,transformation)
+        key = 'hnf-%s-%s' % (include_zero_rows, transformation)
         ans = self.fetch(key)
         if ans is not None:
             return ans
@@ -2261,7 +2262,7 @@ cdef class Matrix_integer_dense(Matrix_dense):
             if i > 0:
                 d = d[i:] + [d[0]]*i
         else:
-            raise ValueError("algorithm (='%s') unknown"%algorithm)
+            raise ValueError("algorithm (='%s') unknown" % algorithm)
 
         self.cache('elementary_divisors', d)
         return d[:]
@@ -2615,7 +2616,7 @@ cdef class Matrix_integer_dense(Matrix_dense):
             K = _rational_kernel_iml(self).transpose().saturation(proof=proof)
             format = 'computed-iml-int'
         else:
-            raise ValueError('unknown algorithm: %s'%algorithm)
+            raise ValueError('unknown algorithm: %s' % algorithm)
         tm = verbose("done computing right kernel matrix over the integers for %sx%s matrix" % (self.nrows(), self.ncols()),level=1, t=tm)
         return (format, K)
 
@@ -3093,7 +3094,9 @@ cdef class Matrix_integer_dense(Matrix_dense):
         cdef Matrix_integer_dense R = None  # LLL-reduced matrix
         cdef Matrix_integer_dense U = None  # transformation matrix
 
-        tm = verbose("LLL of %sx%s matrix (algorithm %s)"%(self.nrows(), self.ncols(), algorithm))
+        tm = verbose("LLL of %sx%s matrix (algorithm %s)" % (self.nrows(),
+                                                             self.ncols(),
+                                                             algorithm))
         import sage.libs.ntl.all
         ntl_ZZ = sage.libs.ntl.all.ZZ
 
@@ -3171,7 +3174,7 @@ cdef class Matrix_integer_dense(Matrix_dense):
                 else:
                     r = A.LLL_XD(delta, verbose=verb, return_U=transformation)
             else:
-                raise TypeError("algorithm %s not supported"%algorithm)
+                raise TypeError("algorithm %s not supported" % algorithm)
 
             if isinstance(r, tuple):
                 r, UNTL = r
@@ -3209,7 +3212,7 @@ cdef class Matrix_integer_dense(Matrix_dense):
             from .matrix_integer_pari import _lll_pari
             R, U, r = _lll_pari(self)
         else:
-            raise TypeError("algorithm %s not supported"%algorithm)
+            raise TypeError("algorithm %s not supported" % algorithm)
 
         verbose("LLL finished", tm)
         if r is not None:
@@ -3455,7 +3458,7 @@ cdef class Matrix_integer_dense(Matrix_dense):
                 num_per_row = int(density * nc)
                 for i from 0 <= i < self._nrows:
                     for j from 0 <= j < num_per_row:
-                        k = rstate.c_random()%nc
+                        k = rstate.c_random() % nc
                         the_integer_ring._randomize_mpz(tmp,
                                                         x, y, distribution)
                         self.set_unsafe_mpz(i,k,tmp)
@@ -3759,7 +3762,7 @@ cdef class Matrix_integer_dense(Matrix_dense):
         elif algorithm == 'ntl':
             d = self._det_ntl()
         else:
-            raise TypeError("algorithm '%s' not known"%(algorithm))
+            raise TypeError("algorithm '%s' not known" % (algorithm))
 
         self.cache('det', d)
         return d
@@ -3977,7 +3980,7 @@ cdef class Matrix_integer_dense(Matrix_dense):
         cdef fmpz_t fden
         fmpz_init(fden)
         M = self._new(self._nrows,self._ncols)
-        verbose('computing inverse of %s x %s matrix using FLINT'%(self._nrows, self._ncols))
+        verbose('computing inverse of %s x %s matrix using FLINT' % (self._nrows, self._ncols))
         sig_on()
         res = fmpz_mat_inv(M._matrix,fden,self._matrix)
         fmpz_get_mpz(den.value,fden)
@@ -4190,13 +4193,13 @@ cdef class Matrix_integer_dense(Matrix_dense):
             from .matrix_integer_iml import _solve_iml
             X, d = _solve_iml(self, C, right=True)
         else:
-            raise ValueError("Unknown algorithm '%s'"%algorithm)
+            raise ValueError("Unknown algorithm '%s'" % algorithm)
         if d != 1:
             X = (1/d) * X
         if not matrix:
             # Convert back to a vector
             X = (X.base_ring() ** X.nrows())(X.list())
-        verbose('finished solve_right via %s'%algorithm, t)
+        verbose('finished solve_right via %s' % algorithm, t)
         return X
 
     def _solve_iml(self, Matrix_integer_dense B, right=True):
@@ -4560,13 +4563,15 @@ cdef class Matrix_integer_dense(Matrix_dense):
             pivots_ = set(pivots)
             non_pivots = [i for i in range(B.ncols()) if i not in pivots_]
             D = B.matrix_from_columns(non_pivots)
-            t = verbose('calling %s solver'%solver, level=2, caller_name='p-adic echelon')
+            t = verbose('calling %s solver' % solver,
+                        level=2, caller_name='p-adic echelon')
             if solver == 'iml':
                 from .matrix_integer_iml import _solve_iml
                 X, d = _solve_iml(C, D, right=True)
             else:
                 X, d = C._solve_flint(D, right=True)
-            t = verbose('finished %s solver'%solver, level=2, caller_name='p-adic echelon', t=t)
+            t = verbose('finished %s solver' % solver,
+                        level=2, caller_name='p-adic echelon', t=t)
 
             # Step 6: Verify that we had chosen the correct pivot columns.
             pivots_are_right = True
@@ -4786,7 +4791,7 @@ cdef class Matrix_integer_dense(Matrix_dense):
         new_pivots = list(pivots)
         if v != 0:
             i = v.nonzero_positions()[0]
-            assert not (i in pivots), 'WARNING: bug in add_row -- i (=%s) should not be a pivot'%i
+            assert not (i in pivots), 'WARNING: bug in add_row -- i (=%s) should not be a pivot' % i
 
             # If pivot entry is negative negate this row.
             if v[i] < 0:
@@ -4929,7 +4934,7 @@ cdef class Matrix_integer_dense(Matrix_dense):
                 for k from 0 <= k < i:
                     res_rows[i][k] = 0
                 for k from i <= k < ncols:
-                    t = ((<int64_t>u)*T_rows[i][k])%R
+                    t = ((<int64_t>u)*T_rows[i][k]) % R
                     if t < 0:
                         t += R
                     res_rows[i][k] = t
@@ -4939,7 +4944,7 @@ cdef class Matrix_integer_dense(Matrix_dense):
                 for j from 0 <= j < i:
                     q = res_rows[j][i]/d
                     for k from i <= k < ncols:
-                        u = (res_rows[j][k] - (<int64_t>q)*res_rows[i][k])%R
+                        u = (res_rows[j][k] - (<int64_t>q)*res_rows[i][k]) % R
                         if u < 0:
                             u += R
                         res_rows[j][k] = u
@@ -4962,11 +4967,11 @@ cdef class Matrix_integer_dense(Matrix_dense):
             d = ai.c_xgcd_int(T_i_i, T_j_i, &u, &v)
             if d != T_i_i:
                 for k from i <= k < ncols:
-                    B[k] = ((<int64_t>u)*T_rows[i][k] + (<int64_t>v)*T_rows[j][k])%R
+                    B[k] = ((<int64_t>u)*T_rows[i][k] + (<int64_t>v)*T_rows[j][k]) % R
             c1 = T_i_i/d
             c2 = -T_j_i/d
             for k from i <= k < ncols:
-                T_rows[j][k] = ((<int64_t>c1)*T_rows[j][k] + (<int64_t>c2)*T_rows[i][k])%R
+                T_rows[j][k] = ((<int64_t>c1)*T_rows[j][k] + (<int64_t>c2)*T_rows[i][k]) % R
             if d != T_i_i:
                 for k from i <= k < ncols:
                     T_rows[i][k] = B[k]
@@ -5239,6 +5244,16 @@ cdef class Matrix_integer_dense(Matrix_dense):
             [  3   4   5]
             [  6   7   8]
             [  1   5 -10]
+
+        TESTS:
+
+        Ensure that :issue:`11328` is fixed::
+
+            sage: m = matrix([[int(1),int(1)],[int(1),int(1)]])
+            sage: m.insert_row(1,[int(2),int(3)])
+            [1 1]
+            [2 3]
+            [1 1]
         """
         cdef Matrix_integer_dense res = self._new(self._nrows + 1, self._ncols)
         cdef Py_ssize_t j
@@ -5254,7 +5269,8 @@ cdef class Matrix_integer_dense(Matrix_dense):
             for i from 0 <= i < index:
                 fmpz_init_set(fmpz_mat_entry(res._matrix,i,j), fmpz_mat_entry(self._matrix,i,j))
 
-            z = row[j]
+            z = ZZ(row[j])
+
             fmpz_set_mpz(zflint,z.value)
             fmpz_init_set(fmpz_mat_entry(res._matrix,index,j), zflint)
 
@@ -5437,7 +5453,8 @@ cdef class Matrix_integer_dense(Matrix_dense):
 
         name = singular._next_var_name()
         values = str(self.list())[1:-1]
-        singular.eval("intmat %s[%d][%d] = %s"%(name, self.nrows(), self.ncols(), values))
+        singular.eval("intmat %s[%d][%d] = %s" % (name, self.nrows(),
+                                                  self.ncols(), values))
 
         from sage.interfaces.singular import SingularElement
         return SingularElement(singular, 'foobar', name, True)

sage/matrix/matrix_integer_sparse.pyx

@@ -660,7 +660,7 @@ cdef class Matrix_integer_sparse(Matrix_sparse):
             r = Matrix_sparse.rank(self)
             self.cache("rank", r)
         else:
-            raise ValueError("no algorithm '%s'"%algorithm)
+            raise ValueError("no algorithm '%s'" % algorithm)
 
         return r
 

sage/matrix/matrix_rational_dense.pyx

@@ -68,7 +68,7 @@ Test hashing::
 from libc.string cimport strcpy, strlen
 
 from sage.categories.rings import Rings
-from sage.cpython.string cimport char_to_str, str_to_bytes
+from sage.cpython.string cimport char_to_str
 
 from sage.modules.vector_rational_dense cimport Vector_rational_dense
 from sage.ext.stdsage cimport PY_NEW
@@ -357,13 +357,13 @@ cdef class Matrix_rational_dense(Matrix_dense):
                 s = data[k]
                 k += 1
                 if '/' in s:
-                    num, den = [str_to_bytes(n) for n in s.split('/')]
+                    num, den = (n.encode() for n in s.split('/'))
                     if fmpz_set_str(fmpq_mat_entry_num(self._matrix, i, j), num, 32) or \
                        fmpz_set_str(fmpq_mat_entry_den(self._matrix, i, j), den, 32):
                         raise RuntimeError("invalid pickle data")
                 else:
-                    s = str_to_bytes(s)
-                    if fmpz_set_str(fmpq_mat_entry_num(self._matrix, i, j), s, 32):
+                    num = s.encode()
+                    if fmpz_set_str(fmpq_mat_entry_num(self._matrix, i, j), num, 32):
                         raise RuntimeError("invalid pickle data")
                     fmpz_one(fmpq_mat_entry_den(self._matrix, i, j))
 
@@ -1261,7 +1261,7 @@ cdef class Matrix_rational_dense(Matrix_dense):
 
     cdef int fmpz_height(self, fmpz_t h) except -1:
         cdef fmpz_t x
-        cdef int i, j
+        cdef Py_ssize_t i, j
         sig_on()
         fmpz_init(x)
         fmpz_zero(h)
@@ -1503,24 +1503,33 @@ cdef class Matrix_rational_dense(Matrix_dense):
 
         - ``algorithm`` -- an optional specification of an algorithm. One of
 
-          - ``None``: (default) uses flint for small dimension and multimodular otherwise
+          - ``None``: (default) try to pick the best choice,
+
+          - ``'flint'``: use flint library
+            `function <https://flintlib.org/doc/fmpq_mat.html#c.fmpq_mat_rref>`_,
+            which automatically chooses between
+            `classical algorithm <https://flintlib.org/doc/fmpq_mat.html#c.fmpq_mat_rref_classical>`_
+            (Gaussian elimination),
+            `fraction-free multimodular <https://flintlib.org/doc/fmpz_mat.html#c.fmpz_mat_rref_mul>`_,
+            and `fraction-free LU decomposition <https://flintlib.org/doc/fmpz_mat.html#c.fmpz_mat_rref_fflu>`_,
 
-          - ``'flint'``: use the flint library,
+          - ``'flint:classical'``, ``'flint:multimodular'``, ``'flint:fflu'``: use the
+            flint library as above, but select an algorithm explicitly,
 
           - ``'padic'``: an algorithm based on the IML `p`-adic solver,
 
-          - ``'multimodular'``: uses a multimodular algorithm the uses
-            linbox modulo many primes (likely to be faster when coefficients
-            are huge),
+          - ``'multimodular'``: uses a multimodular algorithm implemented in Cython
+            that uses linbox modulo many primes,
+            see :func:`~sage.matrix.misc.matrix_rational_echelon_form_multimodular`,
 
           - ``'classical'``: just clear each column using Gauss elimination.
 
         - ``height_guess``, ``**kwds`` -- all passed to the
-          multimodular algorithm; ignored by other algorithms
+          ``'multimodular'`` algorithm; ignored by other algorithms
 
         - ``proof`` -- boolean or ``None`` (default: None, see
           proof.linear_algebra or sage.structure.proof). Passed to the
-          multimodular algorithm. Note that the Sage global default is
+          ``'multimodular'`` algorithm. Note that the Sage global default is
           ``proof=True``.
 
         EXAMPLES::
@@ -1553,7 +1562,8 @@ cdef class Matrix_rational_dense(Matrix_dense):
         Echelonizing a matrix in place throws away the cache of
         the old matrix (:issue:`14506`)::
 
-            sage: for algo in ["flint", "padic", "multimodular", "classical"]:          # needs sage.libs.linbox
+            sage: for algo in ["flint", "padic", "multimodular", "classical",           # needs sage.libs.linbox
+            ....:              "flint:classical", "flint:multimodular", "flint:fflu"]:
             ....:      a = Matrix(QQ, [[1,2],[3,4]])
             ....:      _ = a.det()          # fills the cache
             ....:      _ = a._clear_denom() # fills the cache
@@ -1565,18 +1575,10 @@ cdef class Matrix_rational_dense(Matrix_dense):
         self.check_mutability()
 
         if algorithm is None:
-            if self._nrows <= 25 or self._ncols <= 25:
-                algorithm = 'flint'
-            else:
-                try:
-                    from sage.matrix.misc import matrix_rational_echelon_form_multimodular
-                except ImportError:
-                    algorithm = 'flint'
-                else:
-                    algorithm = 'multimodular'
+            algorithm = 'flint:multimodular'
 
-        if algorithm == 'flint':
-            pivots = self._echelonize_flint()
+        if algorithm in ('flint', 'flint:classical', 'flint:multimodular', 'flint:fflu'):
+            pivots = self._echelonize_flint(algorithm)
         elif algorithm == 'multimodular':
             pivots = self._echelonize_multimodular(height_guess, proof, **kwds)
         elif algorithm == 'classical':
@@ -1666,12 +1668,16 @@ cdef class Matrix_rational_dense(Matrix_dense):
         self.cache('rank', len(E.pivots()))
         return E
 
-    def _echelonize_flint(self):
+    def _echelonize_flint(self, algorithm: str):
         r"""
+        INPUT: See :meth:`echelonize` for the options.
+        Only options that use flint are allowed, passing other algorithms may
+        trigger undefined behavior.
+
         EXAMPLES::
 
             sage: m = matrix(QQ, 4, range(16))
-            sage: m._echelonize_flint()
+            sage: m._echelonize_flint("flint")
             (0, 1)
             sage: m
             [ 1  0 -1 -2]
@@ -1679,7 +1685,7 @@ cdef class Matrix_rational_dense(Matrix_dense):
             [ 0  0  0  0]
             [ 0  0  0  0]
             sage: m = matrix(QQ, 4, 6, [-1,0,0,-2,-1,-2,-1,0,0,-2,-1,0,3,3,-2,0,0,3,-2,-3,1,1,-2,3])
-            sage: m._echelonize_flint()
+            sage: m._echelonize_flint("flint")
             (0, 1, 2, 5)
             sage: m
             [   1    0    0    2    1    0]
@@ -1688,10 +1694,40 @@ cdef class Matrix_rational_dense(Matrix_dense):
             [   0    0    0    0    0    1]
         """
         self.clear_cache()
+
+        if fmpq_mat_is_empty(self._matrix):
+            return ()
+
         cdef long r
+        cdef fmpz_mat_t Aclear
+        cdef fmpz_t den
 
         sig_on()
-        r = fmpq_mat_rref(self._matrix, self._matrix)
+
+        if algorithm == 'flint':
+            r = fmpq_mat_rref(self._matrix, self._matrix)
+        elif algorithm == 'flint:classical':
+            r = fmpq_mat_rref_classical(self._matrix, self._matrix)
+        else:
+            # copied from fmpq_mat_rref_fraction_free
+            fmpz_mat_init(Aclear, self._nrows, self._ncols)
+            fmpq_mat_get_fmpz_mat_rowwise(Aclear, NULL, self._matrix)
+            fmpz_init(den)
+
+            if algorithm == 'flint:fflu':
+                r = fmpz_mat_rref_fflu(Aclear, den, Aclear)
+            else:
+                assert algorithm == 'flint:multimodular'
+                r = fmpz_mat_rref_mul(Aclear, den, Aclear)
+
+            if r == 0:
+                fmpq_mat_zero(self._matrix)
+            else:
+                fmpq_mat_set_fmpz_mat_div_fmpz(self._matrix, Aclear, den)
+
+            fmpz_mat_clear(Aclear)
+            fmpz_clear(den)
+
         sig_off()
 
         # compute pivots

sage/matrix/matrix_rational_sparse.pyx

@@ -237,7 +237,7 @@ cdef class Matrix_rational_sparse(Matrix_sparse):
         cdef mpq_vector* v
 
         # Build a table that gives the nonzero positions in each column of right
-        nonzero_positions_in_columns = [set([]) for _ in range(right._ncols)]
+        nonzero_positions_in_columns = [set() for _ in range(right._ncols)]
         cdef Py_ssize_t i, j, k
         for i in range(right._nrows):
             v = &(right._matrix[i])
@@ -375,7 +375,7 @@ cdef class Matrix_rational_sparse(Matrix_sparse):
         cdef mpz_t x, h
         mpz_init(x)
         mpz_init_set_si(h, 0)
-        cdef int i, j
+        cdef Py_ssize_t i, j
         sig_on()
         for i from 0 <= i < self._nrows:
             for j from 0 <= j < self._matrix[i].num_nonzero:
@@ -539,7 +539,7 @@ cdef class Matrix_rational_sparse(Matrix_sparse):
             [      0       0       1 238/157]
             [      0       0       0       0]
         """
-        label = 'echelon_form_%s'%algorithm
+        label = 'echelon_form_%s' % algorithm
         x = self.fetch(label)
         if x is not None:
             return x

sage/modular/pollack_stevens/dist.pyx

@@ -213,7 +213,7 @@ cdef class Dist(ModuleElement):
             scalar = new_base(left)
             return V([scalar * new_base(self.moment(i)) for i in range(self.precision_absolute())])
 
-    def is_zero(self, p=None, M=None):
+    def is_zero(self, p=None, M=None) -> bool:
         r"""
         Return ``True`` if the `i`-th moment is zero for all `i` (case ``M`` is
         ``None``) or zero modulo `p^{M-i}` for all `i` (when ``M`` is not
@@ -387,7 +387,7 @@ cdef class Dist(ModuleElement):
                         raise ValueError("not a scalar multiple")
                 v = a.valuation(p)
                 if n - i - v > relprec:
-                    verbose("Reseting alpha: relprec=%s, n-i=%s, v=%s" % (relprec, n - i, v), level = 2)
+                    verbose("Resetting alpha: relprec=%s, n-i=%s, v=%s" % (relprec, n - i, v), level = 2)
                     relprec = n - i - v
                     if padic:
                         alpha = (other._unscaled_moment(i) / a).add_bigoh(n - i)

sage/quivers/algebra.py

@@ -21,8 +21,9 @@ Path Algebras
 #                  https://www.gnu.org/licenses/
 # ****************************************************************************
 
-from sage.misc.cachefunc import cached_method
 from sage.combinat.free_module import CombinatorialFreeModule
+from sage.misc.cachefunc import cached_method
+
 from .algebra_elements import PathAlgebraElement