22970: adapt codes using rational dense matrices

src/sage/algebras/quatalg/quaternion_algebra_cython.pyx

@@ -34,6 +34,10 @@ from .quaternion_algebra_element cimport QuaternionAlgebraElement_rational_field
 from sage.libs.gmp.mpz cimport mpz_t, mpz_lcm, mpz_init, mpz_set, mpz_clear, mpz_init_set, mpz_mul, mpz_fdiv_q, mpz_cmp_si
 from sage.libs.gmp.mpq cimport mpq_set_num, mpq_set_den, mpq_canonicalize
 
+from sage.libs.flint.fmpz cimport fmpz_set_mpz
+from sage.libs.flint.fmpq cimport fmpq_canonicalise
+from sage.libs.flint.fmpq_mat cimport fmpq_mat_entry_num, fmpq_mat_entry_den, fmpq_mat_entry
+
 def integral_matrix_and_denom_from_rational_quaternions(v, reverse=False):
     r"""
     Given a list of rational quaternions, return matrix `A` over `\ZZ`
@@ -142,27 +146,28 @@ def rational_matrix_from_rational_quaternions(v, reverse=False):
     if reverse:
         for i in range(n):
             x = v[i]
-            mpq_set_num(A._matrix[n-i-1][3], x.x)
-            mpq_set_num(A._matrix[n-i-1][2], x.y)
-            mpq_set_num(A._matrix[n-i-1][1], x.z)
-            mpq_set_num(A._matrix[n-i-1][0], x.w)
+            fmpz_set_mpz(fmpq_mat_entry_num(A._matrix, n-i-1, 3), x.x)
+            fmpz_set_mpz(fmpq_mat_entry_num(A._matrix, n-i-1, 2), x.y)
+            fmpz_set_mpz(fmpq_mat_entry_num(A._matrix, n-i-1, 1), x.z)
+            fmpz_set_mpz(fmpq_mat_entry_num(A._matrix, n-i-1, 0), x.w)
 
             if mpz_cmp_si(x.d,1):
                 for j in range(4):
-                    mpq_set_den(A._matrix[n-i-1][j], x.d)
-                    mpq_canonicalize(A._matrix[n-i-1][j])
+                    fmpz_set_mpz(fmpq_mat_entry_den(A._matrix, n-i-1, j), x.d)
+                    fmpq_canonicalise(fmpq_mat_entry(A._matrix, n-i-1, j))
     else:
         for i in range(n):
             x = v[i]
-            mpq_set_num(A._matrix[i][0], x.x)
-            mpq_set_num(A._matrix[i][1], x.y)
-            mpq_set_num(A._matrix[i][2], x.z)
-            mpq_set_num(A._matrix[i][3], x.w)
+            fmpz_set_mpz(fmpq_mat_entry_num(A._matrix, i, 0), x.x)
+            fmpz_set_mpz(fmpq_mat_entry_num(A._matrix, i, 1), x.y)
+            fmpz_set_mpz(fmpq_mat_entry_num(A._matrix, i, 2), x.z)
+            fmpz_set_mpz(fmpq_mat_entry_num(A._matrix, i, 3), x.w)
 
             if mpz_cmp_si(x.d,1):
                 for j in range(4):
-                    mpq_set_den(A._matrix[i][j], x.d)
-                    mpq_canonicalize(A._matrix[i][j])
+                    fmpz_set_mpz(fmpq_mat_entry_den(A._matrix, i, j), x.d)
+                    fmpq_canonicalise(fmpq_mat_entry(A._matrix, i, j))
+
     return A
 
 def rational_quaternions_from_integral_matrix_and_denom(A, Matrix_integer_dense H, Integer d, reverse=False):

src/sage/matrix/matrix2.pyx

@@ -6746,11 +6746,15 @@ cdef class Matrix(matrix1.Matrix):
             [ 1  0 -1]
             [ 0  1  2]
             [ 0  0  0]
+            sage: a = matrix(QQ,2,[1..6])
+            sage: P = a._echelon_in_place_classical(); a
+            [ 1  0 -1]
+            [ 0  1  2]
         """
         tm = verbose('generic in-place Gauss elimination on %s x %s matrix'%(self._nrows, self._ncols))
         cdef Py_ssize_t start_row, c, r, nr, nc, i
         if self.fetch('in_echelon_form'):
-            return
+            return self.fetch('pivots')
 
         self.check_mutability()
         cdef Matrix A
@@ -6762,25 +6766,26 @@ cdef class Matrix(matrix1.Matrix):
         start_row = 0
         pivots = []
 
-        for c from 0 <= c < nc:
+        for c in range(nc):
             sig_check()
-            for r from start_row <= r < nr:
+            for r in range(start_row, nr):
                 if A.get_unsafe(r, c):
                     pivots.append(c)
                     a_inverse = ~A.get_unsafe(r,c)
                     A.rescale_row(r, a_inverse, c)
                     A.swap_rows(r, start_row)
-                    for i from 0 <= i < nr:
+                    for i in range(nr):
                         if i != start_row:
                             if A.get_unsafe(i,c):
                                 minus_b = -A.get_unsafe(i, c)
                                 A.add_multiple_of_row(i, start_row, minus_b, c)
                     start_row = start_row + 1
                     break
-        self.cache('pivots', tuple(pivots))
+        pivots = tuple(pivots)
+        self.cache('pivots', pivots)
         self.cache('in_echelon_form', True)
         self.cache('echelon_form', self)
-        verbose('done with gauss echelon form', tm)
+        return pivots
 
     def extended_echelon_form(self, subdivide=False, **kwds):
         r"""
@@ -15001,4 +15006,4 @@ def _matrix_power_symbolic(A, n):
     else:
         Pinv = ~P
 
-    return P * FJ * Pinv
+    return P * FJ * Pinv