sage.matrix.misc*: Fix doctests

Author: Matthias Koeppe

src/sage/matrix/misc.pyx

@@ -24,10 +24,10 @@ from .matrix_rational_sparse cimport Matrix_rational_sparse
 
 matrix_integer_dense_rational_reconstruction = \
   LazyImport('sage.matrix.misc_flint', 'matrix_integer_dense_rational_reconstruction',
-             deprecation=99999)
+             deprecation=35758)
 hadamard_row_bound_mpfr = \
   LazyImport('sage.matrix.misc_mpfr', 'hadamard_row_bound_mpfr',
-             deprecation=99999)
+             deprecation=35758)
 
 
 def matrix_integer_sparse_rational_reconstruction(Matrix_integer_sparse A, Integer N):
@@ -39,7 +39,8 @@ def matrix_integer_sparse_rational_reconstruction(Matrix_integer_sparse A, Integ
     EXAMPLES::
 
         sage: A = matrix(ZZ, 3, 4, [(1/3)%500, 2, 3, (-4)%500, 7, 2, 2, 3, 4, 3, 4, (5/7)%500], sparse=True)
-        sage: sage.matrix.misc.matrix_integer_sparse_rational_reconstruction(A, 500)
+        sage: from sage.matrix.misc import matrix_integer_sparse_rational_reconstruction
+        sage: matrix_integer_sparse_rational_reconstruction(A, 500)
         [1/3   2   3  -4]
         [  7   2   2   3]
         [  4   3   4 5/7]
@@ -329,29 +330,30 @@ def cmp_pivots(x, y):
     """
     Compare two sequences of pivot columns.
 
-    If x is shorter than y, return -1, i.e., x < y, "not as good".
-    If x is longer than y, then x > y, so "better" and return +1.
-    If the length is the same, then x is better, i.e., x > y
-    if the entries of x are correspondingly <= those of y with
+    If `x` is shorter than `y`, return `-1`, i.e., `x < y`, "not as good".
+    If `x` is longer than `y`, then `x > y`, so "better" and return `+1`.
+    If the length is the same, then `x` is better, i.e., `x > y`
+    if the entries of `x` are correspondingly `\leq` those of `y` with
     one being strictly less.
 
     INPUT:
 
-    - x, y -- lists or tuples of integers
+    - ``x``, ``y`` -- lists or tuples of integers
 
     EXAMPLES:
 
     We illustrate each of the above comparisons. ::
 
-        sage: sage.matrix.misc.cmp_pivots([1,2,3], [4,5,6,7])
+        sage: from sage.matrix.misc import cmp_pivots
+        sage: cmp_pivots([1,2,3], [4,5,6,7])
         -1
-        sage: sage.matrix.misc.cmp_pivots([1,2,3,5], [4,5,6])
+        sage: cmp_pivots([1,2,3,5], [4,5,6])
         1
-        sage: sage.matrix.misc.cmp_pivots([1,2,4], [1,2,3])
+        sage: cmp_pivots([1,2,4], [1,2,3])
         -1
-        sage: sage.matrix.misc.cmp_pivots([1,2,3], [1,2,3])
+        sage: cmp_pivots([1,2,3], [1,2,3])
         0
-        sage: sage.matrix.misc.cmp_pivots([1,2,3], [1,2,4])
+        sage: cmp_pivots([1,2,3], [1,2,4])
         1
     """
     x = tuple(x)

src/sage/matrix/misc_flint.pyx

@@ -21,18 +21,19 @@ def matrix_integer_dense_rational_reconstruction(Matrix_integer_dense A, Integer
     """
     Given a matrix over the integers and an integer modulus, do
     rational reconstruction on all entries of the matrix, viewed as
-    numbers mod N.  This is done efficiently by assuming there is a
+    numbers mod `N`.  This is done efficiently by assuming there is a
     large common factor dividing the denominators.
 
     INPUT:
 
-        A -- matrix
-        N -- an integer
+    - ``A`` -- matrix
+    - ``N`` -- an integer
 
     EXAMPLES::
 
         sage: B = ((matrix(ZZ, 3,4, [1,2,3,-4,7,2,18,3,4,3,4,5])/3)%500).change_ring(ZZ)
-        sage: sage.matrix.misc.matrix_integer_dense_rational_reconstruction(B, 500)
+        sage: from sage.matrix.misc import matrix_integer_dense_rational_reconstruction
+        sage: matrix_integer_dense_rational_reconstruction(B, 500)
         [ 1/3  2/3    1 -4/3]
         [ 7/3  2/3    6    1]
         [ 4/3    1  4/3  5/3]
@@ -42,7 +43,7 @@ def matrix_integer_dense_rational_reconstruction(Matrix_integer_dense A, Integer
     Check that :trac:`9345` is fixed::
 
         sage: A = random_matrix(ZZ, 3)
-        sage: sage.matrix.misc.matrix_integer_dense_rational_reconstruction(A, 0)
+        sage: matrix_integer_dense_rational_reconstruction(A, 0)
         Traceback (most recent call last):
         ...
         ZeroDivisionError: The modulus cannot be zero

src/sage/matrix/misc_mpfr.pyx

@@ -14,31 +14,31 @@ from .matrix0 cimport Matrix
 
 def hadamard_row_bound_mpfr(Matrix A):
     """
-    Given a matrix A with entries that coerce to RR, compute the row
+    Given a matrix `A` with entries that coerce to ``RR``, compute the row
     Hadamard bound on the determinant.
 
     INPUT:
 
-        A -- a matrix over RR
+    - ``A`` -- a matrix over ``RR``
 
     OUTPUT:
 
-        integer -- an integer n such that the absolute value of the
-                   determinant of this matrix is at most $10^n$.
+    integer -- an integer n such that the absolute value of the
+    determinant of this matrix is at most `10^n`.
 
     EXAMPLES:
 
     We create a very large matrix, compute the row Hadamard bound,
     and also compute the row Hadamard bound of the transpose, which
     happens to be sharp. ::
 
-        sage: a = matrix(ZZ, 2, [2^10000,3^10000,2^50,3^19292])
-        sage: import sage.matrix.misc
-        sage: sage.matrix.misc.hadamard_row_bound_mpfr(a.change_ring(RR))
+        sage: a = matrix(ZZ, 2, [2^10000, 3^10000, 2^50, 3^19292])
+        sage: from sage.matrix.misc import hadamard_row_bound_mpfr
+        sage: hadamard_row_bound_mpfr(a.change_ring(RR))
         13976
         sage: len(str(a.det()))
         12215
-        sage: sage.matrix.misc.hadamard_row_bound_mpfr(a.transpose().change_ring(RR))
+        sage: hadamard_row_bound_mpfr(a.transpose().change_ring(RR))
         12215
 
     Note that in the above example using RDF would overflow::