Test pickle of Dummy, make Dummy SymPy-convertible (roundtrip)

Author: bjodah

symengine/lib/symengine.pxd

@@ -323,6 +323,7 @@ cdef extern from "<symengine/basic.h>" namespace "SymEngine":
     rcp_const_basic make_rcp_Symbol "SymEngine::make_rcp<const SymEngine::Symbol>"(string name) nogil
     rcp_const_basic make_rcp_Dummy "SymEngine::make_rcp<const SymEngine::Dummy>"() nogil
     rcp_const_basic make_rcp_Dummy "SymEngine::make_rcp<const SymEngine::Dummy>"(string name) nogil
+    rcp_const_basic make_rcp_Dummy "SymEngine::make_rcp<const SymEngine::Dummy>"(string &name, size_t index) nogil
     rcp_const_basic make_rcp_PySymbol "SymEngine::make_rcp<const SymEngine::PySymbol>"(string name, PyObject * pyobj, bool use_pickle) except +
     rcp_const_basic make_rcp_Constant "SymEngine::make_rcp<const SymEngine::Constant>"(string name) nogil
     rcp_const_basic make_rcp_Infty "SymEngine::make_rcp<const SymEngine::Infty>"(RCP[const Number] i) nogil

symengine/lib/symengine_wrapper.in.pyx

@@ -278,10 +278,10 @@ def sympy2symengine(a, raise_error=False):
     """
     import sympy
     from sympy.core.function import AppliedUndef as sympy_AppliedUndef
-    if isinstance(a, sympy.Symbol):
+    if isinstance(a, sympy.Dummy):
+        return Dummy(a.name, a.dummy_index)
+    elif isinstance(a, sympy.Symbol):
         return Symbol(a.name)
-    elif isinstance(a, sympy.Dummy):
-        return Dummy(a.name)
     elif isinstance(a, sympy.Mul):
         return mul(*[sympy2symengine(x, raise_error) for x in a.args])
     elif isinstance(a, sympy.Add):
@@ -1301,10 +1301,10 @@ cdef class Symbol(Expr):
         return sympy.Symbol(str(self))
 
     def __reduce__(self):
-        if type(self) == Symbol:
+        if type(self) in (Symbol, Dummy):
             return Basic.__reduce__(self)
         else:
-            raise NotImplementedError("pickling for Symbol subclass not implemented")
+            raise NotImplementedError("pickling for subclass of Symbol or Dummy not implemented")
 
     def _sage_(self):
         import sage.all as sage
@@ -1337,15 +1337,20 @@ cdef class Symbol(Expr):
 
 cdef class Dummy(Symbol):
 
-    def __init__(Basic self, name=None, *args, **kwargs):
-        if name is None:
-            self.thisptr = symengine.make_rcp_Dummy()
+    def __init__(Basic self, name=None, dummy_index=None, *args, **kwargs):
+        cdef size_t index
+        if dummy_index is None:
+            if name is None:
+                self.thisptr = symengine.make_rcp_Dummy()
+            else:
+                self.thisptr = symengine.make_rcp_Dummy(name.encode("utf-8"))
         else:
-            self.thisptr = symengine.make_rcp_Dummy(name.encode("utf-8"))
+            index = dummy_index
+            self.thisptr = symengine.make_rcp_Dummy(name.encode("utf-8"), index)
 
     def _sympy_(self):
         import sympy
-        return sympy.Dummy(str(self)[1:])
+        return sympy.Dummy(name=self.name, dummy_index=self.dummy_index)
 
     @property
     def is_Dummy(self):

symengine/tests/test_pickling.py

@@ -1,4 +1,4 @@
-from symengine import symbols, sin, sinh, have_numpy, have_llvm, cos, Symbol
+from symengine import symbols, sin, sinh, have_numpy, have_llvm, cos, Symbol, Dummy
 from symengine.test_utilities import raises
 import pickle
 import unittest
@@ -57,3 +57,19 @@ def test_llvm_double():
     ll = pickle.loads(ss)
     inp = [1, 2, 3]
     assert np.allclose(l(inp), ll(inp))
+
+
+def _check_pickling_roundtrip(arg):
+    s2 = pickle.dumps(arg)
+    arg2 = pickle.loads(s2)
+    assert arg == arg2
+    s3 = pickle.dumps(arg2)
+    arg3 = pickle.loads(s3)
+    assert arg == arg3
+
+
+def test_pickling_roundtrip():
+    x, y, z = symbols('x y z')
+    _check_pickling_roundtrip(x+y)
+    _check_pickling_roundtrip(Dummy('d'))
+    _check_pickling_roundtrip(Dummy('d') - z)

symengine/tests/test_symbol.py

@@ -157,6 +157,8 @@ def test_dummy():
     xdummy1 = Dummy('x')
     xdummy2 = Dummy('x')
     assert xdummy1.dummy_index != xdummy2.dummy_index  # maybe test using "less than"?
+    assert xdummy1.name == 'x'
+    assert xdummy2.name == 'x'
 
     assert x1 == x2
     assert x1 != xdummy1

symengine/tests/test_sympy_conv.py

@@ -1,6 +1,6 @@
 from symengine import (Symbol, Integer, sympify, SympifyError, log,
         function_symbol, I, E, pi, oo, zoo, nan, true, false,
-        exp, gamma, have_mpfr, have_mpc, DenseMatrix, sin, cos, tan, cot,
+        exp, gamma, have_mpfr, have_mpc, DenseMatrix, Dummy, sin, cos, tan, cot,
         csc, sec, asin, acos, atan, acot, acsc, asec, sinh, cosh, tanh, coth,
         asinh, acosh, atanh, acoth, atan2, Add, Mul, Pow, diff, GoldenRatio,
         Catalan, EulerGamma, UnevaluatedExpr, RealDouble)
@@ -833,3 +833,24 @@ def test_conv_large_integers():
     if have_sympy:
         c = a._sympy_()
         d = sympify(c)
+
+
+def _check_sympy_roundtrip(arg):
+    arg_sy1 = sympy.sympify(arg)
+    arg_se2 = sympify(arg_sy1)
+    assert arg == arg_se2
+    arg_sy2 = sympy.sympify(arg_se2)
+    assert arg_sy2 == arg_sy1
+    arg_se3 = sympify(arg_sy2)
+    assert arg_se3 == arg
+
+
+@unittest.skipIf(not have_sympy, "SymPy not installed")
+def test_sympy_roundtrip():
+    x = Symbol("x")
+    y = Symbol("y")
+    d = Dummy("d")
+    _check_sympy_roundtrip(x)
+    _check_sympy_roundtrip(x+y)
+    _check_sympy_roundtrip(x**y)
+    _check_sympy_roundtrip(d)

symengine_version.txt

@@ -1 +1 @@
-c9510fb4b5c30b84adb993573a51f2a9a38a4cfe
+c574fa8d7018a850481afa7a59809d30e774d78d