22024: symbolic placeholder for complex root

Author: rwst

src/sage/functions/all.py

@@ -25,7 +25,8 @@
                     abs_symbolic, sqrt, log_gamma,
                     gamma_inc, incomplete_gamma, gamma_inc_lower,
                     arg, real_part, real, frac,
-                    imag_part, imag, imaginary, conjugate, cases)
+                    imag_part, imag, imaginary, conjugate, cases,
+                    complex_root_of)
 
 from .log import (exp, exp_polar, log, ln, polylog, dilog, lambert_w, harmonic_number)
 

src/sage/functions/other.py

@@ -2696,3 +2696,82 @@ def _sympy_(self, l):
 
 cases = Function_cases()
 
+
+class Function_crootof(BuiltinFunction):
+    """
+    Formal function holding ``(polynomial, index)`` pairs.
+
+    The expression evaluates to a floating point value that is an
+    approximation to a specific complex root of the polynomial. The
+    ordering is fixed so you always get the same root.
+
+    The functionality is imported from SymPy, see
+    http://docs.sympy.org/latest/_modules/sympy/polys/rootoftools.html
+
+    EXAMPLES::
+
+        sage: c = complex_root_of(x^6 + x + 1, 1); c
+        complex_root_of(x^6 + x + 1, 1)
+        sage: c.n()
+        -0.790667188814418 + 0.300506920309552*I
+        sage: c.n(100)
+        -0.79066718881441764449859281847 + 0.30050692030955162512001002521*I
+        sage: (c^6 + c + 1).n(100) < 1e-25
+        True
+    """
+    def __init__(self):
+        """
+        EXAMPLES::
+
+            sage: loads(dumps(complex_root_of))
+            complex_root_of
+        """
+        BuiltinFunction.__init__(self, "complex_root_of", nargs=2,
+                                   conversions=dict(sympy='CRootOf'))
+
+    def _eval_(self, poly, index):
+        """
+        TESTS::
+
+            sage: _ = var('y')
+            sage: complex_root_of(1, 1)
+            Traceback (most recent call last):
+            ...
+            ValueError: polynomial in one variable required
+            sage: complex_root_of(x+y, 1)
+            Traceback (most recent call last):
+            ...
+            ValueError: polynomial in one variable required
+            sage: complex_root_of(sin(x), 1)
+            Traceback (most recent call last):
+            ...
+            ValueError: polynomial in one variable required
+        """
+        try:
+            vars = poly.variables()
+        except AttributeError:
+            raise ValueError('polynomial in one variable required')
+        if len(vars) != 1 or not poly.is_polynomial(vars[0]):
+            raise ValueError('polynomial in one variable required')
+
+    def _evalf_(self, poly, index, parent=None, algorithm=None):
+        """
+        EXAMPLES::
+
+            sage: complex_root_of(x^2-2, 1).n()
+            1.41421356237310
+            sage: complex_root_of(x^2-2, 3).n()
+            Traceback (most recent call last):
+            ...
+            IndexError: root index out of [-2, 1] range, got 3
+        """
+        from sympy.polys import CRootOf, Poly
+        try:
+            prec = parent.precision()
+        except AttributeError:
+            prec = 53
+        sobj = CRootOf(Poly(poly._sympy_()), int(index))
+        return sobj.n(ceil(prec*3/10))._sage_()
+
+complex_root_of = Function_crootof()
+

src/sage/interfaces/sympy.py

@@ -578,6 +578,24 @@ def _sympysage_abs(self):
     from sage.functions.other import abs_symbolic
     return abs_symbolic(self.args[0]._sage_())
 
+def _sympysage_crootof(self):
+    """
+    EXAMPLES::
+
+        sage: from sympy import Symbol, CRootOf
+        sage: sobj = CRootOf(Symbol('x')**2 - 2, 1)
+        sage: assert complex_root_of(x^2-2, 1)._sympy_() == sobj
+        sage: assert complex_root_of(x^2-2, 1) == sobj._sage_()
+
+        sage: from sympy import solve as ssolve
+        sage: sols = ssolve(x^6+x+1, x)
+        sage: (sols[0]+1)._sage_().n()
+        0.209332811185582 - 0.300506920309552*I
+    """
+    from sage.functions.other import complex_root_of
+    from sage.symbolic.ring import SR
+    return complex_root_of(self.args[0]._sage_(), SR(self.args[1]))
+
 def _sympysage_relational(self):
     """
     EXAMPLES::
@@ -672,6 +690,7 @@ def sympy_init():
     from sympy.functions.special.tensor_functions import KroneckerDelta
     from sympy.logic.boolalg import BooleanTrue, BooleanFalse
     from sympy.integrals.integrals import Integral
+    from sympy.polys.rootoftools import CRootOf
     from sympy.series.order import Order
 
     Float._sage_ = _sympysage_float
@@ -715,6 +734,7 @@ def sympy_init():
     re._sage_ = _sympysage_re
     im._sage_ = _sympysage_im
     Abs._sage_ = _sympysage_abs
+    CRootOf._sage_ = _sympysage_crootof
     BooleanFalse._sage_ = _sympysage_false
     BooleanTrue._sage_ = _sympysage_true
     ceiling._sage_ = _sympysage_ceiling