Merge branch 'master' into dummy_index

Author: bjodah

symengine/lib/symengine.pxd

@@ -771,6 +771,7 @@ cdef extern from "<symengine/prime_sieve.h>" namespace "SymEngine":
         unsigned next_prime() nogil
 
 cdef extern from "<symengine/visitor.h>" namespace "SymEngine":
+    bool has_basic(const Basic &b, const Basic &x) nogil except +
     bool has_symbol(const Basic &b, const Basic &x) nogil except +
     rcp_const_basic coeff(const Basic &b, const Basic &x, const Basic &n) nogil except +
     set_basic free_symbols(const Basic &b) nogil except +

symengine/lib/symengine_wrapper.in.pyx

@@ -1187,8 +1187,11 @@ cdef class Basic(object):
         cdef Basic _n = sympify(n)
         return c2py(symengine.coeff(deref(self.thisptr), deref(_x.thisptr), deref(_n.thisptr)))
 
-    def has(self, *symbols):
-        return any([has_symbol(self, symbol) for symbol in symbols])
+    def has(self, *args):
+        for arg in args:
+            if has_basic(self, arg):
+                return True
+        return False
 
     def args_as_sage(Basic self):
         cdef symengine.vec_basic Y = deref(self.thisptr).get_args()
@@ -1399,6 +1402,10 @@ cdef class Constant(Expr):
     def is_number(self):
         return True
 
+    @property
+    def is_Atom(self):
+        return True
+
     def _sympy_(self):
         raise Exception("Unknown Constant")
 
@@ -4952,6 +4959,11 @@ def powermod_list(a, b, m):
         s.append(c2py(<rcp_const_basic>(v[i])))
     return s
 
+def has_basic(obj, looking_for=None):
+    cdef Basic b = _sympify(obj)
+    cdef Basic s = _sympify(looking_for)
+    return symengine.has_basic(deref(b.thisptr), deref(s.thisptr))
+
 def has_symbol(obj, symbol=None):
     cdef Basic b = _sympify(obj)
     cdef Basic s = _sympify(symbol)

symengine/tests/test_expr.py

@@ -1,4 +1,4 @@
-from symengine import Symbol, Integer, oo
+from symengine import Symbol, Integer, oo, sin
 from symengine.test_utilities import raises
 
 
@@ -26,3 +26,18 @@ def test_as_powers_dict():
     assert (x*(1/Integer(2))**y).as_powers_dict() == {x: Integer(1), Integer(2): -y}
     assert (2**y).as_powers_dict() == {2: y}
     assert (2**-y).as_powers_dict() == {2: -y}
+
+
+def test_Basic__has():
+    x = Symbol('x')
+    y = Symbol('y')
+    xpowy = x**y
+    e = sin(xpowy)
+    assert e.has(x)
+    assert e.has(y)
+    assert e.has(xpowy)
+    raises(Exception, lambda: e.has(x+1))  # subtree matching of associative operators not yet supported
+    assert (x + oo).has(oo)
+    assert (x - oo).has(-oo)
+    assert not (x + oo).has(-oo)
+    #assert not (x - oo).has(oo) <-- not sure we want to test explicitly for "x + NegativeInfinity"

symengine/tests/test_functions.py

@@ -86,6 +86,7 @@ def test_derivative():
 
     fxy = Function("f")(x, y)
     assert (1+fxy).has(fxy)
+    assert (1+fxy).has(1)
     g = Derivative(Function("f")(x, y), x, 2, y, 1)
     assert g == fxy.diff(x, x, y)
     assert g == fxy.diff(y, 1, x, 2)

symengine/tests/test_number.py

@@ -97,6 +97,7 @@ def test_is_conditions():
     assert i.is_complex
 
     assert pi.is_number
+    assert pi.is_Atom
 
 
 def test_perfect_power():

symengine_version.txt

@@ -1 +1 @@
-c574fa8d7018a850481afa7a59809d30e774d78d
+8a3bc848cd8246a4c15eee9bddc15de0d1157812