Merge pull request #179 from ShikharJ/Misc

Miscellaneous Additions

Author: isuruf

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

@@ -460,6 +460,16 @@ def sympify(a):
     """
     if isinstance(a, str):
         return c2py(symengine.parse(a.encode("utf-8")))
+    elif isinstance(a, tuple):
+        v = []
+        for e in a:
+            v.append(sympify(e))
+        return tuple(v)
+    elif isinstance(a, list):
+        v = []
+        for e in a:
+            v.append(sympify(e))
+        return v
     return _sympify(a, True)
 
 
@@ -494,16 +504,6 @@ def _sympify(a, raise_error=True):
         return RealDouble(a)
     elif isinstance(a, complex):
         return ComplexDouble(a)
-    elif isinstance(a, tuple):
-        v = []
-        for e in a:
-            v.append(_sympify(e, True))
-        return tuple(v)
-    elif isinstance(a, list):
-        v = []
-        for e in a:
-            v.append(_sympify(e, True))
-        return v
     elif hasattr(a, '_symengine_'):
         return _sympify(a._symengine_(), raise_error)
     elif hasattr(a, '_sympy_'):
@@ -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)
@@ -885,6 +890,9 @@ cdef class Basic(object):
     def is_Matrix(self):
         return False
 
+    def copy(self):
+        return self
+
     def _symbolic_(self, ring):
         return ring(self._sage_())
 
@@ -1406,6 +1414,10 @@ class Integer(Rational):
     def is_integer(self):
         return True
 
+    @property
+    def doit(self, **hints):
+        return self
+
     def __hash__(Basic self):
         return deref(self.thisptr).hash()
 
@@ -1740,7 +1752,20 @@ class NaN(Number):
         import sage.all as sage
         return sage.NaN
 
-class Add(Basic):
+
+class AssocOp(Basic):
+
+    @classmethod
+    def make_args(cls, expr):
+        if isinstance(expr, cls):
+            return expr.args
+        else:
+            return (sympify(expr),)
+
+
+class Add(AssocOp):
+
+    identity = 0
 
     def __new__(cls, *args, **kwargs):
         cdef symengine.vec_basic v_
@@ -1750,6 +1775,15 @@ class Add(Basic):
             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
@@ -1783,7 +1817,9 @@ class Add(Basic):
             inc(iter)
         return d
 
-class Mul(Basic):
+class Mul(AssocOp):
+
+    identity = 1
 
     def __new__(cls, *args, **kwargs):
         cdef symengine.vec_basic v_
@@ -1793,6 +1829,15 @@ class Mul(Basic):
             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
@@ -1828,6 +1873,19 @@ class Pow(Basic):
     def __new__(cls, a, b):
         return _sympify(a) ** b
 
+    @property
+    def base(Basic self):
+        cdef RCP[const symengine.Pow] X = symengine.rcp_static_cast_Pow(self.thisptr)
+        return c2py(deref(X).get_base())
+
+    @property
+    def exp(Basic self):
+        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)

symengine/tests/test_sympify.py

@@ -9,6 +9,8 @@ def test_sympify1():
     assert sympify(2) != Integer(1)
     assert sympify(-5) == Integer(-5)
     assert sympify(Integer(3)) == Integer(3)
+    assert sympify(('0', '0')) == (0, 0)
+    assert sympify(['0', '0']) == [0, 0]
     assert sympify("3+5") == Integer(8)
     assert true == sympify(True)
     assert false == sympify(False)