Use evalf from symengine

Author: isuruf

symengine/lib/symengine.pxd

@@ -182,7 +182,6 @@ cdef extern from "<symengine/basic.h>" namespace "SymEngine":
         unsigned int hash() nogil except +
         vec_basic get_args() nogil
         int __cmp__(const Basic &o) nogil
-    ctypedef rcp_const_basic rcp_const_basic "SymEngine::RCP<const SymEngine::Basic>"
     ctypedef RCP[const Number] rcp_const_number "SymEngine::RCP<const SymEngine::Number>"
     ctypedef unordered_map[int, rcp_const_basic] umap_int_basic "SymEngine::umap_int_basic"
     ctypedef unordered_map[int, rcp_const_basic].iterator umap_int_basic_iterator "SymEngine::umap_int_basic::iterator"
@@ -958,6 +957,9 @@ cdef extern from "<utility>" namespace "std":
     cdef map_basic_basic std_move_map_basic_basic "std::move" (map_basic_basic) nogil
     cdef PiecewiseVec std_move_PiecewiseVec "std::move" (PiecewiseVec) nogil
 
+cdef extern from "<symengine/eval.h>" namespace "SymEngine":
+    rcp_const_basic evalf(const Basic &b, unsigned long bits, bool real) nogil except +
+
 cdef extern from "<symengine/eval_double.h>" namespace "SymEngine":
     double eval_double(const Basic &b) nogil except +
     double complex eval_complex_double(const Basic &b) nogil except +

symengine/lib/symengine_wrapper.pyx

@@ -915,11 +915,8 @@ cdef class Basic(object):
         symengine.as_real_imag(self.thisptr, symengine.outArg(_real), symengine.outArg(_imag))
         return c2py(<rcp_const_basic>_real), c2py(<rcp_const_basic>_imag)
 
-    def n(self, prec = 53, real = False):
-        if real:
-            return eval_real(self, prec)
-        else:
-            return eval(self, prec)
+    def n(self, unsigned long prec = 53, cppbool real=False):
+        return evalf(self, prec, real)
 
     evalf = n
 
@@ -3994,13 +3991,17 @@ def Xnor(*args):
         v.push_back(symengine.rcp_static_cast_Boolean(e_.thisptr))
     return c2py(<rcp_const_basic>(symengine.logical_xnor(v)))
 
-def eval_double(x):
+def evalf(x, unsigned long bits=53, cppbool real=False):
     cdef Basic X = sympify(x)
-    return c2py(<rcp_const_basic>(symengine.real_double(symengine.eval_double(deref(X.thisptr)))))
+    return c2py(<rcp_const_basic>(symengine.evalf(deref(X.thisptr), bits, real)))
+
+def eval_double(x):
+    warnings.warn("eval_double is deprecated. Use evalf(..., real=True)", DeprecationWarning)
+    return evalf(x, 53, real=True)
 
 def eval_complex_double(x):
-    cdef Basic X = sympify(x)
-    return c2py(<rcp_const_basic>(symengine.complex_double(symengine.eval_complex_double(deref(X.thisptr)))))
+    warnings.warn("eval_complex_double is deprecated. Use evalf(..., real=False)", DeprecationWarning)
+    return evalf(x, 53, real=False)
 
 have_mpfr = False
 have_mpc = False
@@ -4010,19 +4011,15 @@ have_llvm = False
 
 IF HAVE_SYMENGINE_MPFR:
     have_mpfr = True
-    def eval_mpfr(x, long prec):
-        cdef Basic X = sympify(x)
-        cdef symengine.mpfr_class a = symengine.mpfr_class(prec)
-        symengine.eval_mpfr(a.get_mpfr_t(), deref(X.thisptr), symengine.MPFR_RNDN)
-        return c2py(<rcp_const_basic>(symengine.real_mpfr(symengine.std_move_mpfr(a))))
+    def eval_mpfr(x, unsigned long prec):
+        warnings.warn("eval_mpfr is deprecated. Use evalf(..., real=True)", DeprecationWarning)
+        return evalf(x, prec, real=True)
 
 IF HAVE_SYMENGINE_MPC:
     have_mpc = True
-    def eval_mpc(x, long prec):
-        cdef Basic X = sympify(x)
-        cdef symengine.mpc_class a = symengine.mpc_class(prec)
-        symengine.eval_mpc(a.get_mpc_t(), deref(X.thisptr), symengine.MPFR_RNDN)
-        return c2py(<rcp_const_basic>(symengine.complex_mpc(symengine.std_move_mpc(a))))
+    def eval_mpc(x, unsigned long prec):
+        warnings.warn("eval_mpc is deprecated. Use evalf(..., real=False)", DeprecationWarning)
+        return evalf(x, prec, real=True)
 
 IF HAVE_SYMENGINE_PIRANHA:
     have_piranha = True
@@ -4038,22 +4035,12 @@ def require(obj, t):
         raise TypeError("{} required. {} is of type {}".format(t, obj, type(obj)))
 
 def eval(x, long prec):
-    if prec <= 53:
-        return eval_complex_double(x)
-    else:
-        IF HAVE_SYMENGINE_MPC:
-            return eval_mpc(x, prec)
-        ELSE:
-            raise ValueError("Precision %s is only supported with MPC" % prec)
+    warnings.warn("eval is deprecated. Use evalf(..., real=False)", DeprecationWarning)
+    return evalf(x, prec, real=False)
 
 def eval_real(x, long prec):
-    if prec <= 53:
-        return eval_double(x)
-    else:
-        IF HAVE_SYMENGINE_MPFR:
-            return eval_mpfr(x, prec)
-        ELSE:
-            raise ValueError("Precision %s is only supported with MPFR" % prec)
+    warnings.warn("eval_real is deprecated. Use evalf(..., real=True)", DeprecationWarning)
+    return evalf(x, prec, real=True)
 
 def probab_prime_p(n, reps = 25):
     cdef Basic _n = sympify(n)

symengine/tests/test_eval.py

@@ -1,27 +1,24 @@
 from symengine.utilities import raises
 from symengine import (Symbol, sin, cos, Integer, Add, I, RealDouble, ComplexDouble, sqrt)
 
-from symengine.lib.symengine_wrapper import eval_double
 from unittest.case import SkipTest
 
 def test_eval_double1():
     x = Symbol("x")
     y = Symbol("y")
     e = sin(x)**2 + cos(x)**2
     e = e.subs(x, 7)
-    assert abs(eval_double(e) - 1) < 1e-9
+    assert abs(e.n(real=True) - 1) < 1e-9
 
 
 def test_eval_double2():
     x = Symbol("x")
-    y = Symbol("y")
-    e = sin(x)**2 + cos(x)**2
-    raises(RuntimeError, lambda: (abs(eval_double(e) - 1) < 1e-9))
-
+    e = sin(x)**2 + sqrt(2)
+    assert abs(e.n(real=True) - x**2 - 1.414) < 1e-3
 
 def test_n():
     x = Symbol("x")
-    raises(RuntimeError, lambda: (x.n()))
+    assert x.n(real=True) == x + 0.0
 
     x = 2 + I
     raises(RuntimeError, lambda: (x.n(real=True)))