Trac #32742: Use sage.rings.abc.RealField, sage.rings.abc.ComplexField more

As a follow-up on #32566 and #32610, we replace `isinstance` tests with
`RealField_class` by the `sage.rings.abc.RealField`.

`git grep -E 'isinstance.*(Real|Complex)Field_class'` finds these uses.

URL: https://trac.sagemath.org/32742
Reported by: mkoeppe
Ticket author(s): Matthias Koeppe
Reviewer(s): Travis Scrimshaw

Author: Release Manager

src/sage/ext/fast_callable.pyx

@@ -302,9 +302,7 @@ AUTHOR:
 
 import operator
 from copy import copy
-from sage.rings.real_mpfr cimport RealField_class, RealNumber
-from sage.rings.complex_mpfr import ComplexField_class
-from sage.rings.all import RDF, CDF
+import sage.rings.abc
 from sage.rings.integer import Integer
 from sage.rings.integer_ring import ZZ
 from sage.structure.element cimport parent
@@ -466,41 +464,34 @@ def fast_callable(x, domain=None, vars=None,
         etb = ExpressionTreeBuilder(vars=vars, domain=domain)
         et = x._fast_callable_(etb)
 
-    if isinstance(domain, RealField_class):
-        import sage.ext.interpreters.wrapper_rr
-        builder = sage.ext.interpreters.wrapper_rr.Wrapper_rr
-
+    if isinstance(domain, sage.rings.abc.RealField):
+        from sage.ext.interpreters.wrapper_rr import Wrapper_rr as builder
         str = InstructionStream(sage.ext.interpreters.wrapper_rr.metadata,
                                 len(vars),
                                 domain)
 
-    elif isinstance(domain, ComplexField_class):
-        import sage.ext.interpreters.wrapper_cc
-        builder = sage.ext.interpreters.wrapper_cc.Wrapper_cc
+    elif isinstance(domain, sage.rings.abc.ComplexField):
+        from sage.ext.interpreters.wrapper_cc import Wrapper_cc as builder
         str = InstructionStream(sage.ext.interpreters.wrapper_cc.metadata,
                                 len(vars),
                                 domain)
 
-    elif domain == RDF or domain is float:
-        import sage.ext.interpreters.wrapper_rdf
-        builder = sage.ext.interpreters.wrapper_rdf.Wrapper_rdf
+    elif isinstance(domain, sage.rings.abc.RealDoubleField) or domain is float:
+        from sage.ext.interpreters.wrapper_rdf import Wrapper_rdf as builder
         str = InstructionStream(sage.ext.interpreters.wrapper_rdf.metadata,
                                 len(vars),
                                 domain)
-    elif domain == CDF:
-        import sage.ext.interpreters.wrapper_cdf
-        builder = sage.ext.interpreters.wrapper_cdf.Wrapper_cdf
+    elif isinstance(domain, sage.rings.abc.ComplexDoubleField):
+        from sage.ext.interpreters.wrapper_cdf import Wrapper_cdf as builder
         str = InstructionStream(sage.ext.interpreters.wrapper_cdf.metadata,
                                 len(vars),
                                 domain)
     elif domain is None:
-        import sage.ext.interpreters.wrapper_py
-        builder = sage.ext.interpreters.wrapper_py.Wrapper_py
+        from sage.ext.interpreters.wrapper_py import Wrapper_py as builder
         str = InstructionStream(sage.ext.interpreters.wrapper_py.metadata,
                                 len(vars))
     else:
-        import sage.ext.interpreters.wrapper_el
-        builder = sage.ext.interpreters.wrapper_el.Wrapper_el
+        from sage.ext.interpreters.wrapper_el import Wrapper_el as builder
         str = InstructionStream(sage.ext.interpreters.wrapper_el.metadata,
                                 len(vars),
                                 domain)

src/sage/geometry/voronoi_diagram.py

@@ -17,8 +17,7 @@
 from sage.geometry.polyhedron.constructor import Polyhedron
 from sage.rings.qqbar import AA
 from sage.rings.rational_field import QQ
-from sage.rings.real_double import RDF
-from sage.rings.real_mpfr import RealField_class
+import sage.rings.abc
 from sage.geometry.triangulation.point_configuration import PointConfiguration
 from sage.modules.free_module_element import vector
 from sage.plot.all import line, point, rainbow, plot
@@ -103,9 +102,10 @@ def __init__(self, points):
         self._n = self._points.n_points()
         if not self._n or self._points.base_ring().is_subring(QQ):
             self._base_ring = QQ
-        elif self._points.base_ring() in [RDF, AA]:
+        elif isinstance(self._points.base_ring(), sage.rings.abc.RealDoubleField) or self._points.base_ring() == AA:
             self._base_ring = self._points.base_ring()
-        elif isinstance(self._points.base_ring(), RealField_class):
+        elif isinstance(self._points.base_ring(), sage.rings.abc.RealField):
+            from sage.rings.real_double import RDF
             self._base_ring = RDF
             self._points = PointConfiguration([[RDF(cor) for cor in poi]
                                                for poi in self._points])

src/sage/groups/lie_gps/nilpotent_lie_group.py

@@ -26,7 +26,7 @@
 from sage.misc.cachefunc import cached_method
 from sage.misc.repr import repr_lincomb
 from sage.modules.free_module_element import vector
-from sage.rings.real_mpfr import RealField_class
+import sage.rings.abc
 from sage.structure.element import MultiplicativeGroupElement
 from sage.symbolic.ring import SR, var
 
@@ -229,7 +229,7 @@ def __init__(self, L, name, **kwds):
         R = L.base_ring()
         category = kwds.pop('category', None)
         category = LieGroups(R).or_subcategory(category)
-        if isinstance(R, RealField_class):
+        if isinstance(R, sage.rings.abc.RealField):
             structure = RealDifferentialStructure()
         else:
             structure = DifferentialStructure()

src/sage/groups/misc_gps/argument_groups.py

@@ -46,7 +46,7 @@
 from sage.structure.parent import Parent
 from sage.structure.richcmp import richcmp_by_eq_and_lt
 from sage.structure.unique_representation import UniqueRepresentation
-
+import sage.rings.abc
 
 class AbstractArgument(MultiplicativeGroupElement):
     r"""
@@ -1870,13 +1870,13 @@ def create_key_and_extra_args(self,
 
         if domain is not None:
             if domain in (ZZ, QQ, AA) \
-               or isinstance(domain, (RealField_class,
-                                      RealIntervalField_class,
-                                      RealBallField)):
+               or isinstance(domain, (sage.rings.abc.RealField,
+                                      sage.rings.abc.RealIntervalField,
+                                      sage.rings.abc.RealBallField)):
                 return (SignGroup, ()), kwds
-            elif isinstance(domain, (ComplexField_class,
-                                     ComplexIntervalField_class,
-                                     ComplexBallField)):
+            elif isinstance(domain, (sage.rings.abc.ComplexField,
+                                     sage.rings.abc.ComplexIntervalField,
+                                     sage.rings.abc.ComplexBallField)):
                 return (UnitCircleGroup, (domain._real_field(),)), kwds
             else:
                 return (ArgumentByElementGroup, (domain,)), kwds

src/sage/manifolds/manifold.py

@@ -328,9 +328,9 @@
 from sage.categories.fields import Fields
 from sage.categories.manifolds import Manifolds
 from sage.categories.homset import Hom
+import sage.rings.abc
 from sage.rings.all import CC
-from sage.rings.real_mpfr import RR, RealField_class
-from sage.rings.complex_mpfr import ComplexField_class
+from sage.rings.real_mpfr import RR
 from sage.misc.prandom import getrandbits
 from sage.misc.cachefunc import cached_method
 from sage.rings.integer import Integer
@@ -545,9 +545,9 @@ def __init__(self, n, name, field, structure, base_manifold=None,
             if field not in Fields():
                 raise TypeError("the argument 'field' must be a field")
             self._field = field
-            if isinstance(field, RealField_class):
+            if isinstance(field, sage.rings.abc.RealField):
                 self._field_type = 'real'
-            elif isinstance(field, ComplexField_class):
+            elif isinstance(field, sage.rings.abc.ComplexField):
                 self._field_type = 'complex'
             else:
                 self._field_type = 'neither_real_nor_complex'
@@ -2957,7 +2957,7 @@ def Manifold(dim, name, latex_name=None, field='real', structure='smooth',
     unique_tag = lambda: getrandbits(128)*_manifold_id
 
     if structure in ['topological', 'top']:
-        if field == 'real' or isinstance(field, RealField_class):
+        if field == 'real' or isinstance(field, sage.rings.abc.RealField):
             structure = RealTopologicalStructure()
         else:
             structure = TopologicalStructure()
@@ -2985,7 +2985,7 @@ def Manifold(dim, name, latex_name=None, field='real', structure='smooth',
                                  "not compatible with a smooth structure")
         else:
             diff_degree = infinity
-        if field == 'real' or isinstance(field, RealField_class):
+        if field == 'real' or isinstance(field, sage.rings.abc.RealField):
             structure = RealDifferentialStructure()
         else:
             structure = DifferentialStructure()

src/sage/manifolds/vector_bundle.py

@@ -37,9 +37,9 @@
 from sage.structure.category_object import CategoryObject
 from sage.categories.vector_bundles import VectorBundles
 from sage.structure.unique_representation import UniqueRepresentation
+import sage.rings.abc
 from sage.rings.all import CC
-from sage.rings.real_mpfr import RR, RealField_class
-from sage.rings.complex_mpfr import ComplexField_class
+from sage.rings.real_mpfr import RR
 from sage.rings.integer import Integer
 from sage.manifolds.vector_bundle_fiber import VectorBundleFiber
 
@@ -218,9 +218,9 @@ def __init__(self, rank, name, base_space, field='real',
             self._field_type = field
         else:
             self._field = field
-            if isinstance(field, RealField_class):
+            if isinstance(field, sage.rings.abc.RealField):
                 self._field_type = 'real'
-            elif isinstance(field, ComplexField_class):
+            elif isinstance(field, sage.rings.abc.ComplexField):
                 self._field_type = 'complex'
             else:
                 self._field_type = 'neither_real_nor_complex'

src/sage/matrix/misc.pyx

@@ -40,7 +40,7 @@ from sage.rings.rational_field import QQ
 from sage.rings.integer cimport Integer
 from sage.arith.all import previous_prime, CRT_basis
 
-from sage.rings.real_mpfr cimport RealField_class
+cimport sage.rings.abc
 from sage.rings.real_mpfr cimport RealNumber
 
 
@@ -510,7 +510,7 @@ def hadamard_row_bound_mpfr(Matrix A):
         ...
         OverflowError: cannot convert float infinity to integer
     """
-    if not isinstance(A.base_ring(), RealField_class):
+    if not isinstance(A.base_ring(), sage.rings.abc.RealField):
         raise TypeError("A must have base field an mpfr real field.")
 
     cdef RealNumber a, b

src/sage/quadratic_forms/quadratic_form__split_local_covering.py

@@ -11,7 +11,8 @@
 from sage.quadratic_forms.extras import extend_to_primitive
 from sage.quadratic_forms.quadratic_form import QuadraticForm__constructor, is_QuadraticForm
 
-from sage.rings.real_mpfr import RealField_class, RealField
+import sage.rings.abc
+from sage.rings.real_mpfr import RealField
 from sage.rings.real_double import RDF
 from sage.matrix.matrix_space import MatrixSpace
 from sage.matrix.constructor import matrix
@@ -84,7 +85,7 @@ def cholesky_decomposition(self, bit_prec = 53):
     """
 
     ## Check that the precision passed is allowed.
-    if isinstance(self.base_ring(), RealField_class) and (self.base_ring().prec() < bit_prec):
+    if isinstance(self.base_ring(), sage.rings.abc.RealField) and (self.base_ring().prec() < bit_prec):
         raise RuntimeError("Oops! The precision requested is greater than that of the given quadratic form!")
 
     ## 1. Initialization

src/sage/rings/asymptotic/asymptotic_ring.py

@@ -418,6 +418,7 @@
 from sage.structure.element import CommutativeAlgebraElement
 from sage.structure.unique_representation import UniqueRepresentation
 from sage.misc.defaults import series_precision
+import sage.rings.abc
 from sage.rings.all import RIF
 from .misc import WithLocals
 
@@ -2964,8 +2965,7 @@ def plot_comparison(self, variable, function, values, rescaled=True,
         points = self.compare_with_values(variable, function,
                                           values, rescaled=rescaled, ring=ring)
 
-        from sage.rings.real_mpfi import RealIntervalField_class
-        if isinstance(ring, RealIntervalField_class):
+        if isinstance(ring, sage.rings.abc.RealIntervalField):
             if not all(p[1].relative_diameter() <= relative_tolerance for p in points):
                 raise ValueError('Numerical noise is too high, the '
                                  'comparison is inaccurate')

src/sage/rings/asymptotic/growth_group.py

@@ -240,6 +240,7 @@
 from sage.structure.unique_representation import (CachedRepresentation,
                                                   UniqueRepresentation)
 from sage.structure.richcmp import richcmp_by_eq_and_lt
+import sage.rings.abc
 from .misc import WithLocals
 
 
@@ -3622,13 +3623,12 @@ def _convert_(self, data):
             from sage.symbolic.ring import SR
             return self._convert_(SR(data))
 
-        from sage.symbolic.ring import SymbolicRing
         from sage.rings.polynomial.polynomial_ring import PolynomialRing_general
         from sage.rings.polynomial.multi_polynomial_ring_base import \
             MPolynomialRing_base
         from sage.rings.power_series_ring import PowerSeriesRing_generic
         import operator
-        if isinstance(P, SymbolicRing):
+        if isinstance(P, sage.rings.abc.SymbolicRing):
             if data.operator() == operator.pow:
                 base, exponent = data.operands()
                 if str(base) == var:
@@ -4419,10 +4419,9 @@ def __init__(self, base, *args, **kwds):
             sage: forget()
         """
         from warnings import warn
-        from sage.symbolic.ring import SymbolicRing
 
         super(ExponentialGrowthGroup, self).__init__(base, *args, **kwds)
-        if isinstance(base, SymbolicRing) and not self._an_element_base_() > 0:
+        if isinstance(base, sage.rings.abc.SymbolicRing) and not self._an_element_base_() > 0:
             warn("When using the Exponential {}, make "
                  "assumptions on the used symbolic elements.\n"
                  "In particular, use something like "
@@ -4552,9 +4551,8 @@ def _convert_(self, data):
         import operator
         from sage.functions.log import Function_exp
         from sage.symbolic.operators import mul_vararg
-        from sage.symbolic.ring import SymbolicRing
 
-        if isinstance(P, SymbolicRing):
+        if isinstance(P, sage.rings.abc.SymbolicRing):
             op = data.operator()
             if op == operator.pow:
                 base, exponent = data.operands()
@@ -4654,38 +4652,31 @@ def _split_raw_element_(base):
             (-x, -1)
             sage: forget()
         """
-        from sage.rings.complex_arb import ComplexBallField
-        from sage.rings.complex_mpfr import ComplexField_class
-        from sage.rings.complex_interval_field import ComplexIntervalField_class
         from sage.rings.integer_ring import ZZ
         from sage.rings.rational_field import QQ
-        from sage.rings.real_arb import RealBallField
-        from sage.rings.real_mpfr import RealField_class
-        from sage.rings.real_mpfi import RealIntervalField_class
         from sage.rings.qqbar import AA
         from sage.structure.element import parent
-        from sage.symbolic.ring import SymbolicRing
 
         P = base.parent()
-        if isinstance(P, SymbolicRing):
+        if isinstance(P, sage.rings.abc.SymbolicRing):
             try:
                 base = base.pyobject()
             except TypeError:
                 pass
             else:
                 P = base.parent()
 
-        if P in (ZZ, QQ, AA) or isinstance(P, (SymbolicRing,
-                                               RealField_class,
-                                               RealIntervalField_class,
-                                               RealBallField)):
+        if P in (ZZ, QQ, AA) or isinstance(P, (sage.rings.abc.SymbolicRing,
+                                               sage.rings.abc.RealField,
+                                               sage.rings.abc.RealIntervalField,
+                                               sage.rings.abc.RealBallField)):
             if base > 0:
                 return base, None
             if base < 0:
                 return -base, -1
-        elif isinstance(P, (ComplexField_class,
-                            ComplexIntervalField_class,
-                            ComplexBallField)):
+        elif isinstance(P, (sage.rings.abc.ComplexField,
+                            sage.rings.abc.ComplexIntervalField,
+                            sage.rings.abc.ComplexBallField)):
             size = abs(base)
             direction = base / size
             return size, direction
@@ -4847,9 +4838,6 @@ def factory(cls,
         from sage.categories.cartesian_product import cartesian_product
         from sage.groups.misc_gps.argument_groups import AbstractArgumentGroup
         from sage.groups.misc_gps.argument_groups import ArgumentGroup
-        from sage.rings.complex_arb import ComplexBallField
-        from sage.rings.complex_mpfr import ComplexField_class
-        from sage.rings.complex_interval_field import ComplexIntervalField_class
         from sage.rings.number_field.number_field import NumberField_cyclotomic
         from sage.rings.qqbar import QQbar, AA
 
@@ -4861,9 +4849,9 @@ def factory(cls,
                 UU = cls._non_growth_group_class_(
                     ArgumentGroup(domain=base), var)
                 groups = (EE, UU)
-            elif isinstance(base, (ComplexField_class,
-                                   ComplexIntervalField_class,
-                                   ComplexBallField)):
+            elif isinstance(base, (sage.rings.abc.ComplexField,
+                                   sage.rings.abc.ComplexIntervalField,
+                                   sage.rings.abc.ComplexBallField)):
                 EE = cls(base._real_field(), var, **kwds)
                 UU = cls._non_growth_group_class_(
                     ArgumentGroup(exponents=base._real_field()), var)