Trac #28508: An API for testing if a parent's element “are” real/complex numbers

See commit messages.

URL: https://trac.sagemath.org/28508
Reported by: mmezzarobba
Ticket author(s): Marc Mezzarobba
Reviewer(s): Vincent Delecroix

Author: Release Manager

src/sage/numerical/linear_functions.pyx

@@ -716,11 +716,8 @@ cdef class LinearFunctionsParent_class(Parent):
             sage: parent._coerce_map_from_(int)
             True
         """
-        if R in [int, float, long, complex]:
-            return True
-        from sage.rings.real_mpfr import mpfr_prec_min
-        from sage.rings.all import RealField
-        if RealField(mpfr_prec_min()).has_coerce_map_from(R):
+        from sage.structure.coerce import parent_is_real_numerical
+        if parent_is_real_numerical(R) or R is complex:
             return True
         return False
 

src/sage/rings/infinity.py

@@ -1243,8 +1243,8 @@ def _coerce_map_from_(self, R):
             sage: CC(0, oo) < CC(1)   # does not coerce to infinity ring
             True
         """
-        from sage.rings.real_mpfr import mpfr_prec_min, RealField
-        if RealField(mpfr_prec_min()).has_coerce_map_from(R):
+        from sage.structure.coerce import parent_is_real_numerical
+        if parent_is_real_numerical(R):
             return True
         from sage.rings.real_mpfi import RealIntervalField_class
         if isinstance(R, RealIntervalField_class):

src/sage/rings/number_field/number_field.py

@@ -2950,11 +2950,8 @@ def specified_complex_embedding(self):
               Defn: a -> 3 + 7 + 2*7^2 + 6*7^3 + 7^4 + 2*7^5 + 7^6 + 2*7^7 + 4*7^8 + 6*7^9 + 6*7^10 + 2*7^11 + 7^12 + 7^13 + 2*7^15 + 7^16 + 7^17 + 4*7^18 + 6*7^19 + O(7^20)
         """
         embedding = self.coerce_embedding()
-        if embedding is not None:
-            from sage.rings.real_mpfr import mpfr_prec_min
-            from sage.rings.complex_field import ComplexField
-            if ComplexField(mpfr_prec_min()).has_coerce_map_from(embedding.codomain()):
-                 return embedding
+        if embedding is not None and embedding.codomain()._is_numerical():
+            return embedding
 
     def gen_embedding(self):
         """

src/sage/rings/number_field/number_field_morphisms.pyx

@@ -488,9 +488,9 @@ def root_from_approx(f, a):
     P = a.parent()
     if P.is_exact() and not f(a):
         return a
-    elif RealField(mpfr_prec_min()).has_coerce_map_from(P):
+    elif P._is_real_numerical():
         return LazyAlgebraic(RLF, f, a, prec=0)
-    elif ComplexField(mpfr_prec_min()).has_coerce_map_from(P):
+    elif P._is_numerical():
         return LazyAlgebraic(CLF, f, a, prec=0)
     # p-adic lazy, when implemented, would go here
     else:

src/sage/structure/coerce.pyx

@@ -365,6 +365,55 @@ cpdef bint parent_is_integers(P) except -1:
         from sage.rings.integer_ring import ZZ
         return P is ZZ
 
+def parent_is_numerical(P):
+    r"""
+    Test if elements of the parent or type ``P`` can be numerically evaluated
+    as complex numbers (in a canonical way).
+
+    EXAMPLES::
+
+        sage: from sage.structure.coerce import parent_is_numerical
+        sage: import gmpy2, numpy
+        sage: [parent_is_numerical(R) for R in [RR, CC, QQ, QuadraticField(-1),
+        ....:         int, complex, gmpy2.mpc, numpy.complexfloating]]
+        [True, True, True, True, True, True, True, True]
+        sage: [parent_is_numerical(R) for R in [SR, QQ['x'], QQ[['x']], str]]
+        [False, False, False, False]
+        sage: [parent_is_numerical(R) for R in [RIF, RBF, CIF, CBF]]
+        [False, False, False, False]
+    """
+    if not isinstance(P, Parent):
+        P = py_scalar_parent(P)
+        if P is None:
+            return False
+    return P._is_numerical()
+
+def parent_is_real_numerical(P):
+    r"""
+    Test if elements of the parent or type ``P`` can be numerically evaluated
+    as real numbers (in a canonical way).
+
+    EXAMPLES::
+
+        sage: from sage.structure.coerce import parent_is_real_numerical
+        sage: import gmpy2, numpy
+        sage: [parent_is_real_numerical(R) for R in [RR, QQ, ZZ, RLF,
+        ....:         QuadraticField(2), int, float, gmpy2.mpq, numpy.integer]]
+        [True, True, True, True, True, True, True, True, True]
+        sage: [parent_is_real_numerical(R) for R in [CC, QuadraticField(-1),
+        ....:         complex, gmpy2.mpc, numpy.complexfloating]]
+        [False, False, False, False, False]
+        sage: [parent_is_real_numerical(R) for R in [SR, QQ['x'], QQ[['x']], str]]
+        [False, False, False, False]
+        sage: [parent_is_real_numerical(R) for R in [RIF, RBF, CIF, CBF]]
+        [False, False, False, False]
+    """
+    if not isinstance(P, Parent):
+        P = py_scalar_parent(P)
+        if P is None:
+            return False
+    return P._is_real_numerical()
+
 
 cpdef bint is_numpy_type(t):
     """

src/sage/structure/parent.pyx

@@ -117,6 +117,7 @@ cimport sage.categories.map as map
 from sage.structure.debug_options cimport debug
 from sage.structure.richcmp cimport rich_to_bool
 from sage.structure.sage_object cimport SageObject
+from sage.misc.cachefunc import cached_method
 from sage.misc.lazy_attribute import lazy_attribute
 from sage.categories.sets_cat import Sets, EmptySetError
 from sage.misc.lazy_format import LazyFormat
@@ -2703,6 +2704,44 @@ cdef class Parent(sage.structure.category_object.CategoryObject):
         """
         return True
 
+    @cached_method
+    def _is_numerical(self):
+        r"""
+        Test if elements of this parent can be numerically evaluated as complex
+        numbers (in a canonical way).
+
+        EXAMPLES::
+
+            sage: [R._is_numerical() for R in [RR, CC, QQ, QuadraticField(-1)]]
+            [True, True, True, True]
+            sage: [R._is_numerical() for R in [SR, QQ['x'], QQ[['x']]]]
+            [False, False, False]
+            sage: [R._is_numerical() for R in [RIF, RBF, CIF, CBF]]
+            [False, False, False, False]
+        """
+        from sage.rings.complex_field import ComplexField
+        from sage.rings.real_mpfr import mpfr_prec_min
+        return ComplexField(mpfr_prec_min()).has_coerce_map_from(self)
+
+    @cached_method
+    def _is_real_numerical(self):
+        r"""
+        Test if elements of this parent can be numerically evaluated as real
+        numbers (in a canonical way).
+
+        EXAMPLES::
+
+            sage: [R._is_real_numerical() for R in [RR, QQ, ZZ, RLF, QuadraticField(2)]]
+            [True, True, True, True, True]
+            sage: [R._is_real_numerical() for R in [CC, QuadraticField(-1)]]
+            [False, False]
+            sage: [R._is_real_numerical() for R in [SR, QQ['x'], QQ[['x']]]]
+            [False, False, False]
+            sage: [R._is_real_numerical() for R in [RIF, RBF, CIF, CBF]]
+            [False, False, False, False]
+        """
+        from sage.rings.real_mpfr import RealField, mpfr_prec_min
+        return RealField(mpfr_prec_min()).has_coerce_map_from(self)
 
 ############################################################################
 # Set base class --

src/sage/symbolic/ring.pyx

@@ -203,7 +203,7 @@ cdef class SymbolicRing(CommutativeRing):
 
             from .subring import GenericSymbolicSubring
 
-            if ComplexField(mpfr_prec_min()).has_coerce_map_from(R):
+            if R._is_numerical():
                 # Almost anything with a coercion into any precision of CC
                 return R not in (RLF, CLF)
             elif is_PolynomialRing(R) or is_MPolynomialRing(R) or is_FractionField(R) or is_LaurentPolynomialRing(R):

src/sage/symbolic/subring.py

@@ -411,9 +411,7 @@ def _coerce_map_from_(self, P):
             # Workaround; can be deleted once #19231 is fixed
             return False
 
-        from sage.rings.real_mpfr import mpfr_prec_min
-        from sage.rings.all import (ComplexField,
-                                    RLF, CLF, AA, QQbar, InfinityRing)
+        from sage.rings.all import RLF, CLF, AA, QQbar, InfinityRing
         from sage.rings.real_mpfi import is_RealIntervalField
         from sage.rings.complex_interval_field import is_ComplexIntervalField
 
@@ -430,7 +428,7 @@ def _coerce_map_from_(self, P):
               is_RealIntervalField(P) or is_ComplexIntervalField(P)):
             return True
 
-        elif ComplexField(mpfr_prec_min()).has_coerce_map_from(P):
+        elif P._is_numerical():
             return P not in (RLF, CLF, AA, QQbar)
 
     def __eq__(self, other):