Implement Add, Not, Or and Xor

Author: ShikharJ

symengine/lib/symengine.pxd

@@ -297,6 +297,10 @@ cdef extern from "<symengine/basic.h>" namespace "SymEngine":
     bool is_a_Interval "SymEngine::is_a<SymEngine::Interval>"(const Basic &b) nogil
     bool is_a_Piecewise "SymEngine::is_a<SymEngine::Piecewise>"(const Basic &b) nogil
     bool is_a_Contains "SymEngine::is_a<SymEngine::Contains>"(const Basic &b) nogil
+    bool is_a_And "SymEngine::is_a<SymEngine::And>"(const Basic &b) nogil
+    bool is_a_Not "SymEngine::is_a<SymEngine::Not>"(const Basic &b) nogil
+    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 +
 
 cdef extern from "<symengine/subs.h>" namespace "SymEngine":
@@ -891,6 +895,14 @@ cdef extern from "<symengine/logic.h>" namespace "SymEngine":
         pass
     cdef cppclass Contains(Boolean):
         pass
+    cdef cppclass And(Boolean):
+        pass
+    cdef cppclass Or(Boolean):
+        pass
+    cdef cppclass Not(Boolean):
+        pass
+    cdef cppclass Xor(Boolean):
+        pass
 
     RCP[const Basic] boolTrue
     RCP[const Basic] boolFalse
@@ -904,6 +916,15 @@ cdef extern from "<symengine/logic.h>" namespace "SymEngine":
     cdef RCP[const Boolean] Lt(RCP[const Basic] &lhs, RCP[const Basic] &rhs) nogil except+
     ctypedef Boolean const_Boolean "const SymEngine::Boolean"
     ctypedef vector[pair[RCP[const_Basic], RCP[const_Boolean]]] PiecewiseVec;
+    ctypedef vector[RCP[const_Boolean]] vec_boolean "SymEngine::vec_boolean"
+    ctypedef set[RCP[const_Boolean], RCPBasicKeyLess] set_boolean "SymEngine::set_boolean"
+    cdef RCP[const Boolean] logical_and(set_boolean &s) nogil except+
+    cdef RCP[const Boolean] logical_nand(set_boolean &s) nogil except+
+    cdef RCP[const Boolean] logical_or(set_boolean &s) nogil except+
+    cdef RCP[const Boolean] logical_not(RCP[const Boolean] &s) nogil except+
+    cdef RCP[const Boolean] logical_nor(set_boolean &s) nogil except+
+    cdef RCP[const Boolean] logical_xor(vec_boolean &s) nogil except+
+    cdef RCP[const Boolean] logical_xnor(vec_boolean &s) nogil except+
     cdef RCP[const Basic] piecewise(PiecewiseVec vec) nogil except +
     cdef RCP[const Boolean] contains(RCP[const Basic] &expr,
                                      RCP[const Set] &set) nogil

symengine/lib/symengine_wrapper.pyx

@@ -192,6 +192,14 @@ cdef c2py(RCP[const symengine.Basic] o):
         r = BooleanAtom.__new__(BooleanAtom)
     elif (symengine.is_a_Interval(deref(o))):
         r = Interval.__new__(Interval)
+    elif (symengine.is_a_And(deref(o))):
+        r = Boolean.__new__(And)
+    elif (symengine.is_a_Not(deref(o))):
+        r = Boolean.__new__(Not)
+    elif (symengine.is_a_Or(deref(o))):
+        r = Boolean.__new__(Or)
+    elif (symengine.is_a_Xor(deref(o))):
+        r = Boolean.__new__(Xor)
     else:
         raise Exception("Unsupported SymEngine class.")
     r.thisptr = o
@@ -355,6 +363,20 @@ def sympy2symengine(a, raise_error=False):
         return ceiling(a.args[0])
     elif isinstance(a, sympy.conjugate):
         return conjugate(a.args[0])
+    elif isinstance(a, sympy.And):
+        return logical_and(*a.args)
+    elif isinstance(a, sympy.Or):
+        return logical_or(*a.args)
+    elif isinstance(a, sympy.Not):
+        return logical_not(a.args[0])
+    elif isinstance(a, sympy.Nor):
+        return logical_nor(*a.args)
+    elif isinstance(a, sympy.Nand):
+        return logical_nand(*a.args)
+    elif isinstance(a, sympy.Xor):
+        return logical_xor(*a.args)
+    elif isinstance(a, sympy.Xnor):
+        return logical_xnor(*a.args)
     elif isinstance(a, sympy.gamma):
         return gamma(a.args[0])
     elif isinstance(a, sympy.Derivative):
@@ -1067,7 +1089,7 @@ cdef class Constant(Basic):
             raise Exception("Unknown Constant")
 
 
-class Boolean(Basic):
+cdef class Boolean(Basic):
     pass
 
 
@@ -1102,6 +1124,30 @@ class BooleanFalse(BooleanAtom):
         return False
 
 
+class And(Boolean):
+
+    def __new__(cls, *args):
+        return logical_and(*args)
+
+
+class Or(Boolean):
+
+    def __new__(cls, *args):
+        return logical_or(*args)
+
+
+class Not(Boolean):
+
+    def __new__(cls, x):
+        return logical_not(x)
+
+
+class Xor(Boolean):
+
+    def __new__(cls, *args):
+        return logical_xor(*args)
+
+
 class Relational(Boolean):
 
     @property
@@ -3363,6 +3409,58 @@ def trigamma(x):
     cdef Basic X = sympify(x)
     return c2py(symengine.trigamma(X.thisptr))
 
+def logical_and(*args):
+    cdef symengine.set_boolean s
+    cdef Boolean e_
+    for e in args:
+        e_ = sympify(e)
+        s.insert(e_.thisptr)
+    return c2py(<RCP[const symengine.Basic]>(symengine.logical_and(s)))
+
+def logical_or(*args):
+    cdef symengine.set_boolean s
+    cdef Boolean e_
+    for e in args:
+        e_ = sympify(e)
+        s.insert(e_.thisptr)
+    return c2py(<RCP[const symengine.Basic]>(symengine.logical_or(s)))
+
+def logical_nor(*args):
+    cdef symengine.set_boolean s
+    cdef Boolean e_
+    for e in args:
+        e_ = sympify(e)
+        s.insert(e_.thisptr)
+    return c2py(<RCP[const symengine.Basic]>(symengine.logical_nor(s)))
+
+def logical_nand(*args):
+    cdef symengine.set_boolean s
+    cdef Boolean e_
+    for e in args:
+        e_ = sympify(e)
+        s.insert(e_.thisptr)
+    return c2py(<RCP[const symengine.Basic]>(symengine.logical_nand(s)))
+
+def logical_not(x):
+    cdef Boolean X = sympify(x)
+    return c2py(<RCP[const symengine.Basic]>(symengine.logical_not(X.thisptr)))
+
+def logical_xor(*args):
+    cdef symengine.vec_boolean v
+    cdef Boolean e_
+    for e in args:
+        e_ = sympify(e)
+        v.push_back(e_.thisptr)
+    return c2py(<RCP[const symengine.Basic]>(symengine.logical_xor(v)))
+
+def logical_xnor(*args):
+    cdef symengine.vec_boolean v
+    cdef Boolean e_
+    for e in args:
+        e_ = sympify(e)
+        v.push_back(e_.thisptr)
+    return c2py(<RCP[const symengine.Basic]>(symengine.logical_xnor(v)))
+
 def eval_double(x):
     cdef Basic X = sympify(x)
     return c2py(<RCP[const symengine.Basic]>(symengine.real_double(symengine.eval_double(deref(X.thisptr)))))