Added Tests

Author: ShikharJ

symengine/lib/symengine.pxd

@@ -311,6 +311,7 @@ cdef extern from "<symengine/basic.h>" namespace "SymEngine":
     bool is_a_Or "SymEngine::is_a<SymEngine::Or>"(const Basic &b) nogil
     bool is_a_Xor "SymEngine::is_a<SymEngine::Xor>"(const Basic &b) nogil
     RCP[const Basic] expand(RCP[const Basic] &o) nogil except +
+    void as_numer_denom(RCP[const Basic] &x, const Ptr[RCP[Basic]] &numer, const Ptr[RCP[Basic]] &denom) nogil
 
 cdef extern from "<symengine/subs.h>" namespace "SymEngine":
     RCP[const Basic] msubs (RCP[const Basic] &x, const map_basic_basic &x) nogil

symengine/lib/symengine_wrapper.pyx

@@ -773,12 +773,17 @@ cdef class Basic(object):
         cdef _DictBasic D = get_dict(*args)
         return c2py(symengine.ssubs(self.thisptr, D.c))
 
-    xreplace = subs
+    replace = xreplace = subs
 
     def msubs(Basic self not None, *args):
         cdef _DictBasic D = get_dict(*args)
         return c2py(symengine.msubs(self.thisptr, D.c))
 
+    def as_numer_denom(Basic self not None):
+        cdef RCP[const symengine.Basic] _num, _den
+        symengine.as_numer_denom(self.thisptr, symengine.outArg(_num), symengine.outArg(_den))
+        return c2py(<RCP[const symengine.Basic]>_num), c2py(<RCP[const symengine.Basic]>_den)
+
     def n(self, prec = 53, real = False):
         if real:
             return eval_real(self, prec)
@@ -886,7 +891,7 @@ cdef class Basic(object):
         return False
 
     def copy(self):
-        return self.func(*self.args)
+        return self
 
     def _symbolic_(self, ring):
         return ring(self._sage_())
@@ -1363,10 +1368,6 @@ class Rational(Number):
                            symengine.outArg_Integer(_num), symengine.outArg_Integer(_den))
         return [c2py(<RCP[const symengine.Basic]>_num), c2py(<RCP[const symengine.Basic]>_den)]
 
-    def as_numer_denom(self):
-        r = self.get_num_den()
-        return r[0], r[1]
-
     def _sympy_(self):
         rat = self.get_num_den()
         return rat[0]._sympy_() / rat[1]._sympy_()
@@ -1486,8 +1487,8 @@ class Integer(Rational):
     def q(self):
         return 1
 
-    def as_numer_denom(Basic self):
-        return self, Integer(1)
+    def get_num_den(Basic self):
+        return self, 1
 
     @property
     def func(self):
@@ -1753,16 +1754,6 @@ class NaN(Number):
 
 
 class AssocOp(Basic):
-    
-    @classmethod
-    def _from_args(cls, args):
-        if len(args) == 0:
-            return cls.identity
-        elif len(args) == 1:
-            return args[0]
-
-        obj = super(AssocOp, cls).__new__(cls, *args)
-        return obj
 
     @classmethod
     def make_args(cls, expr):
@@ -1774,6 +1765,8 @@ class AssocOp(Basic):
 
 class Add(AssocOp):
 
+    identity = 0
+
     def __new__(cls, *args, **kwargs):
         cdef symengine.vec_basic v_
         cdef Basic e
@@ -1782,6 +1775,15 @@ class Add(AssocOp):
             v_.push_back(e.thisptr)
         return c2py(symengine.add(v_))
 
+    @classmethod
+    def _from_args(self, args):
+        if len(args) == 0:
+            return self.identity
+        elif len(args) == 1:
+            return args[0]
+
+        return Add(*args)
+
     @property
     def is_Add(self):
         return True
@@ -1817,6 +1819,8 @@ class Add(AssocOp):
 
 class Mul(AssocOp):
 
+    identity = 1
+
     def __new__(cls, *args, **kwargs):
         cdef symengine.vec_basic v_
         cdef Basic e
@@ -1825,6 +1829,15 @@ class Mul(AssocOp):
             v_.push_back(e.thisptr)
         return c2py(symengine.mul(v_))
 
+    @classmethod
+    def _from_args(self, args):
+        if len(args) == 0:
+            return self.identity
+        elif len(args) == 1:
+            return args[0]
+
+        return Mul(*args)
+
     @property
     def is_Mul(self):
         return True
@@ -1870,6 +1883,9 @@ class Pow(Basic):
         cdef RCP[const symengine.Pow] X = symengine.rcp_static_cast_Pow(self.thisptr)
         return c2py(deref(X).get_exp())
 
+    def as_base_exp(self):
+        return self.base, self.exp
+
     @property
     def is_Pow(self):
         return True

symengine/tests/test_arit.py

@@ -1,6 +1,6 @@
 from symengine.utilities import raises
 
-from symengine import Symbol, Integer, Add, Pow
+from symengine import Symbol, Integer, Add, Mul, Pow, Rational, sqrt
 
 
 def test_arit1():
@@ -149,3 +149,62 @@ def test_free_symbols():
     z = Symbol("z")
     assert (x**2).free_symbols == set([x])
     assert (x**y + z).free_symbols == set([x, y, z])
+
+
+def test_as_numer_denom():
+    x, y = Rational(17, 26).as_numer_denom()
+    assert x == Integer(17)
+    assert y == Integer(26)
+
+    x, y = Integer(-5).as_numer_denom()
+    assert x == Integer(-5)
+    assert y == Integer(1)
+
+
+def test_from_args():
+    x = Symbol("x")
+    y = Symbol("y")
+    
+    assert Add._from_args([]) == 0
+    assert Add._from_args([x]) == x
+    assert Add._from_args([x, y]) == x + y
+
+    assert Mul._from_args([]) == 1
+    assert Mul._from_args([x]) == x
+    assert Mul._from_args([x, y]) == x * y
+
+
+def test_make_args():
+    x = Symbol("x")
+    y = Symbol("y")
+    z = Symbol("z")
+
+    assert Add.make_args(x) == (x,)
+    assert Mul.make_args(x) == (x,)
+
+    assert Add.make_args(x*y*z) == (x*y*z,)
+    assert Mul.make_args(x*y*z) == (x*y*z).args
+
+    assert Add.make_args(x + y + z) == (x + y + z).args
+    assert Mul.make_args(x + y + z) == (x + y + z,)
+
+    assert Add.make_args((x + y)**z) == ((x + y)**z,)
+    assert Mul.make_args((x + y)**z) == ((x + y)**z,)
+
+
+def test_Pow_base_exp():
+    x = Symbol("x")
+    y = Symbol("y")
+    e = Pow(x + y, 2)
+    assert isinstance(e, Pow)
+    assert e.exp == 2
+    assert e.base == x + y
+
+    assert sqrt(x - 1).as_base_exp() == (x - 1, Rational(1, 2))
+
+
+def test_copy():
+    b = Symbol("b")
+    a = b.copy()
+    assert a is b
+    assert type(a) == type(b)