Merge pull request #117 from mattwala/make-symengine-classes-closer-to-sympy

Make symengine.py classes closer to sympy

Author: isuruf

symengine/lib/symengine_wrapper.pyx

@@ -387,6 +387,13 @@ def get_dict(*args):
     return D
 
 
+cdef tuple vec_basic_to_tuple(symengine.vec_basic& vec):
+    result = []
+    for i in range(vec.size()):
+        result.append(c2py(<RCP[const symengine.Basic]>(vec[i])))
+    return tuple(result)
+
+
 cdef class Basic(object):
 
     def __str__(self):
@@ -514,11 +521,8 @@ cdef class Basic(object):
 
     @property
     def args(self):
-        cdef symengine.vec_basic Y = deref(self.thisptr).get_args()
-        s = []
-        for i in range(Y.size()):
-            s.append(c2py(<RCP[const symengine.Basic]>(Y[i])))
-        return tuple(s)
+        cdef symengine.vec_basic args = deref(self.thisptr).get_args()
+        return vec_basic_to_tuple(args)
 
     @property
     def free_symbols(self):
@@ -657,9 +661,14 @@ cdef class Symbol(Basic):
         import sage.all as sage
         return sage.SR.symbol(str(deref(X).get_name().decode("utf-8")))
 
+    @property
     def name(self):
         return self.__str__()
 
+    @property
+    def is_Atom(self):
+        return True
+
     @property
     def is_Symbol(self):
         return True
@@ -837,6 +846,14 @@ cdef class Integer(Number):
     def __float__(self):
         return float(str(self))
 
+    @property
+    def p(self):
+        return int(self)
+
+    @property
+    def q(self):
+        return 1
+
 
 cdef class RealDouble(Number):
 
@@ -956,6 +973,14 @@ cdef class Rational(Number):
     def is_Rational(self):
         return True
 
+    @property
+    def p(self):
+        return self.get_num_den()[0]
+
+    @property
+    def q(self):
+        return self.get_num_den()[1]
+
     def get_num_den(self):
         cdef RCP[const symengine.Integer] _num, _den
         symengine.get_num_den(deref(symengine.rcp_static_cast_Rational(self.thisptr)),
@@ -1302,6 +1327,15 @@ cdef class Derivative(Basic):
     def is_Derivative(self):
         return True
 
+    @property
+    def expr(self):
+        cdef RCP[const symengine.Derivative] X = symengine.rcp_static_cast_Derivative(self.thisptr)
+        return c2py(deref(X).get_arg())
+
+    @property
+    def variables(self):
+        return self.args[1:]
+
     def __cinit__(self, expr = None, symbols = None):
         if expr is None or symbols is None:
             return
@@ -1349,6 +1383,23 @@ cdef class Subs(Basic):
             m[v_.thisptr] = p_.thisptr
         self.thisptr = symengine.make_rcp_Subs(expr_.thisptr, m)
 
+    @property
+    def expr(self):
+        cdef RCP[const symengine.Subs] me = symengine.rcp_static_cast_Subs(self.thisptr)
+        return c2py(deref(me).get_arg())
+
+    @property
+    def variables(self):
+        cdef RCP[const symengine.Subs] me = symengine.rcp_static_cast_Subs(self.thisptr)
+        cdef symengine.vec_basic variables = deref(me).get_variables()
+        return vec_basic_to_tuple(variables)
+
+    @property
+    def point(self):
+        cdef RCP[const symengine.Subs] me = symengine.rcp_static_cast_Subs(self.thisptr)
+        cdef symengine.vec_basic point = deref(me).get_point()
+        return vec_basic_to_tuple(point)
+
     def _sympy_(self):
         cdef RCP[const symengine.Subs] X = symengine.rcp_static_cast_Subs(self.thisptr)
         arg = c2py(deref(X).get_arg())._sympy_()

symengine/tests/test_functions.py

@@ -56,6 +56,10 @@ def test_derivative():
     assert f.diff(x).diff(y) == function_symbol("f", x, y).diff(x).diff(y)
     assert f.diff(Symbol("z")) == 0
 
+    s = Derivative(function_symbol("f", x), [x])
+    assert s.expr == function_symbol("f", x)
+    assert s.variables == (x,)
+
 def test_abs():
     x = Symbol("x")
     e = abs(x)
@@ -86,6 +90,12 @@ def test_Subs():
     assert Subs(Derivative(function_symbol("f", x, y), [x]), [x, y], [_x, x]) \
                 == Subs(Derivative(function_symbol("f", x, y), [x]), [y, x], [x, _x])
 
+    s = f.diff(x)/2
+    _xi_1 = Symbol("_xi_1")
+    assert s.expr == Derivative(function_symbol("f", _xi_1), [_xi_1])
+    assert s.variables == (_xi_1,)
+    assert s.point == (2*x,)
+
 def test_FunctionWrapper():
     import sympy
     n, m, theta, phi = sympy.symbols("n, m, theta, phi")

symengine/tests/test_symbol.py

@@ -4,6 +4,7 @@
 
 def test_symbol():
     x = Symbol("x")
+    assert x.name == "x"
     assert str(x) == "x"
     assert str(x) != "y"
     assert repr(x) == str(x)

symengine/tests/test_sympy_compat.py

@@ -6,11 +6,15 @@ def test_Integer():
     assert isinstance(i, Integer)
     assert isinstance(i, Rational)
     assert isinstance(i, Basic)
+    assert i.p == 5
+    assert i.q == 1
 
 def test_Rational():
     i = S(1)/2
     assert isinstance(i, Rational)
     assert isinstance(i, Basic)
+    assert i.p == 1
+    assert i.q == 2
 
 def test_Add():
     x, y = symbols("x y")