sagemathgh-39137: Minor refactor for is_exact
    
The method is unnecessarily duplicated, which this pull request removes.

Besides, it wasn't originally correctly implemented for modules and
matrix spaces. Fixed now.

Side note: technically a matrix space over R is a (usually
noncommutative) R-algebra, which is in turn a R-module. Yet MatrixSpace
doesn't inherit from Module?

### 📝 Checklist

<!-- Put an `x` in all the boxes that apply. -->

- [x] The title is concise and informative.
- [x] The description explains in detail what this PR is about.
- [x] I have created tests covering the changes.
- [x] I have updated the documentation and checked the documentation
preview.

### ⌛ Dependencies

<!-- List all open PRs that this PR logically depends on. For example,
-->
<!-- - sagemath#12345: short description why this is a dependency -->
<!-- - sagemath#34567: ... -->
    
URL: sagemath#39137
Reported by: user202729
Reviewer(s): Frédéric Chapoton

Author: Release Manager

src/sage/matrix/matrix_space.py

@@ -955,6 +955,24 @@ def characteristic(self):
         """
         return self.base_ring().characteristic()
 
+    def is_exact(self):
+        """
+        Test whether elements of this matrix space are represented exactly.
+
+        OUTPUT:
+
+        Return ``True`` if elements of this matrix space are represented exactly, i.e.,
+        there is no precision loss when doing arithmetic.
+
+        EXAMPLES::
+
+            sage: MatrixSpace(ZZ, 3).is_exact()
+            True
+            sage: MatrixSpace(RR, 3).is_exact()
+            False
+        """
+        return self._base.is_exact()
+
     def _has_default_implementation(self):
         r"""
         EXAMPLES::

src/sage/modules/free_module.py

@@ -998,6 +998,24 @@ def is_sparse(self):
         """
         return self.__is_sparse
 
+    def is_exact(self):
+        """
+        Test whether elements of this module are represented exactly.
+
+        OUTPUT:
+
+        Return ``True`` if elements of this module are represented exactly, i.e.,
+        there is no precision loss when doing arithmetic.
+
+        EXAMPLES::
+
+            sage: (ZZ^2).is_exact()
+            True
+            sage: (RR^2).is_exact()
+            False
+        """
+        return self._base.is_exact()
+
     def _an_element_(self):
         """
         Return an arbitrary element of a free module.

src/sage/rings/ring.pyx

@@ -518,29 +518,6 @@ cdef class Ring(ParentWithGens):
         else:
             return False
 
-    cpdef bint is_exact(self) except -2:
-        """
-        Return ``True`` if elements of this ring are represented exactly, i.e.,
-        there is no precision loss when doing arithmetic.
-
-        .. NOTE::
-
-            This defaults to ``True``, so even if it does return ``True`` you
-            have no guarantee (unless the ring has properly overloaded this).
-
-        EXAMPLES::
-
-            sage: QQ.is_exact()    # indirect doctest
-            True
-            sage: ZZ.is_exact()
-            True
-            sage: Qp(7).is_exact()                                                      # needs sage.rings.padics
-            False
-            sage: Zp(7, type='capped-abs').is_exact()                                   # needs sage.rings.padics
-            False
-        """
-        return True
-
     def order(self):
         """
         The number of elements of ``self``.

src/sage/schemes/elliptic_curves/ell_generic.py

@@ -1076,6 +1076,19 @@ def is_on_curve(self, x, y):
         a = self.ainvs()
         return y**2 + a[0]*x*y + a[2]*y == x**3 + a[1]*x**2 + a[3]*x + a[4]
 
+    def is_exact(self):
+        """
+        Test whether elements of this elliptic curve are represented exactly.
+
+        EXAMPLES::
+
+            sage: EllipticCurve(QQ, [1, 2]).is_exact()
+            True
+            sage: EllipticCurve(RR, [1, 2]).is_exact()
+            False
+        """
+        return self.__base_ring.is_exact()
+
     def a_invariants(self):
         r"""
         The `a`-invariants of this elliptic curve, as a tuple.

src/sage/structure/parent.pyx

@@ -2863,17 +2863,17 @@ cdef class Parent(sage.structure.category_object.CategoryObject):
 
     cpdef bint is_exact(self) except -2:
         """
-        Test whether the ring is exact.
+        Test whether elements of this parent are represented exactly.
 
         .. NOTE::
 
             This defaults to true, so even if it does return ``True``
-            you have no guarantee (unless the ring has properly
+            you have no guarantee (unless the parent has properly
             overloaded this).
 
         OUTPUT:
 
-        Return ``True`` if elements of this ring are represented exactly, i.e.,
+        Return ``True`` if elements of this parent are represented exactly, i.e.,
         there is no precision loss when doing arithmetic.
 
         EXAMPLES::