Wrapped Union, Complement, ConditionSet and ImageSet

symengine/lib/symengine.pxd

@@ -281,6 +281,10 @@ cdef extern from "<symengine/basic.h>" namespace "SymEngine":
     bool is_a_EmptySet "SymEngine::is_a<SymEngine::EmptySet>"(const Basic &b) nogil
     bool is_a_UniversalSet "SymEngine::is_a<SymEngine::UniversalSet>"(const Basic &b) nogil
     bool is_a_FiniteSet "SymEngine::is_a<SymEngine::FiniteSet>"(const Basic &b) nogil
+    bool is_a_Union "SymEngine::is_a<SymEngine::Union>"(const Basic &b) nogil
+    bool is_a_Complement "SymEngine::is_a<SymEngine::Complement>"(const Basic &b) nogil
+    bool is_a_ConditionSet "SymEngine::is_a<SymEngine::ConditionSet>"(const Basic &b) nogil
+    bool is_a_ImageSet "SymEngine::is_a<SymEngine::ImageSet>"(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
@@ -892,7 +896,23 @@ cdef extern from "<symengine/sets.h>" namespace "SymEngine":
         pass
     cdef cppclass FiniteSet(Set):
         pass
+    cdef cppclass Union(Set):
+        pass
+    cdef cppclass Complement(Set):
+        pass
+    cdef cppclass ConditionSet(Set):
+        pass
+    cdef cppclass ImageSet(Set):
+        pass
+    ctypedef Set const_Set "const SymEngine::Set"
+    ctypedef set[RCP[const_Set], RCPBasicKeyLess] set_set "SymEngine::set_set"
     cdef RCP[const Basic] interval(RCP[const Number] &start, RCP[const Number] &end, bool l, bool r) nogil except +
     cdef RCP[const EmptySet] emptyset() nogil except +
     cdef RCP[const UniversalSet] universalset() nogil except +
     cdef RCP[const Set] finiteset(set_basic &container) nogil except +
+    cdef RCP[const Set] set_union(set_set &in) nogil except +
+    cdef RCP[const Set] set_intersection(set_set &in) nogil except +
+    cdef RCP[const Set] set_complement_helper(RCP[const Set] &container, RCP[const Set] &universe) nogil except +
+    cdef RCP[const Set] set_complement(RCP[const Set] &universe RCP[const Set] &container) nogil except +
+    cdef RCP[const Set] conditionset(RCP[const Basic] &sym, RCP[const Boolean] &condition) nogil except +
+    cdef RCP[const Set] imageset(RCP[const Basic] &sym, RCP[const Basic] &expr, RCP[const Set] &base) nogil except +

symengine/lib/symengine_wrapper.pyx

@@ -160,6 +160,14 @@ cdef c2py(RCP[const symengine.Basic] o):
         r = UniversalSet.__new__(UniversalSet)
     elif (symengine.is_a_FiniteSet(deref(o))):
         r = FiniteSet.__new__(FiniteSet)
+    elif (symengine.is_a_Union(deref(o))):
+        r = Union.__new__(Union)
+    elif (symengine.is_a_Complement(deref(o))):
+        r = Complement.__new__(Complement)
+    elif (symengine.is_a_ConditionSet(deref(o))):
+        r = ConditionSet.__new__(ConditionSet)
+    elif (symengine.is_a_ImageSet(deref(o))):
+        r = ImageSet.__new__(ImageSet)
     elif (symengine.is_a_And(deref(o))):
         r = Boolean.__new__(And)
     elif (symengine.is_a_Not(deref(o))):
@@ -326,6 +334,16 @@ def sympy2symengine(a, raise_error=False):
         return finiteset(*(a.args))
     elif isinstance(a, sympy.Contains):
         return contains(*(a.args))
+    elif isinstance(a, sympy.Union):
+        return set_union(*(a.args))
+    elif isinstance(a, sympy.Intersection):
+        return set_intersection(*(a.args))
+    elif isinstance(a, sympy.Complement):
+        return set_complement(*(a.args))
+    elif isinstance(a, sympy.ConditionSet):
+        return conditionset(*(a.args))
+    elif isinstance(a, sympy.ImageSet):
+        return imageset(*(a.args))
     elif isinstance(a, sympy.Function):
         return PyFunction(a, a.args, a.func, sympy_module)
     elif isinstance(a, sympy.MatrixBase):
@@ -2179,6 +2197,46 @@ cdef class Contains(Boolean):
         return sympy.Contains(*[arg._sympy_() for arg in self.args])
 
 
+cdef class Union(Set):
+
+    def __new__(self, *args):
+        return set_union(*args)
+
+    def _sympy_(self):
+        import sympy
+        return sympy.Union(*[arg._sympy_() for arg in self.args])
+
+
+cdef class Complement(Set):
+
+    def __new__(self, universe, container):
+        return set_complement(universe, container)
+
+    def _sympy_(self):
+        import sympy
+        return sympy.Complement(*[arg._sympy_() for arg in self.args])
+
+
+cdef class ConditionSet(Set):
+
+    def __new__(self, sym, condition):
+        return conditionset(sym, condition)
+
+    def _sympy_(self):
+        import sympy
+        return sympy.ConditionSet(*[arg._sympy_() for arg in self.args])
+
+
+cdef class ImageSet(Set):
+
+    def __new__(self, sym, expr, base):
+        return imageset(sym, expr, base)
+
+    def _sympy_(self):
+        import sympy
+        return sympy.ImageSet(*[arg._sympy_() for arg in self.args])
+
+
 cdef class MatrixBase:
 
     @property
@@ -3856,7 +3914,7 @@ def universalset():
     return c2py(<RCP[const symengine.Basic]>(symengine.universalset()))
 
 
-def finiteset(*args)
+def finiteset(*args):
     cdef symengine.set_basic s
     cdef Basic e_
     for e in args:
@@ -3872,5 +3930,53 @@ def contains(expr, sset):
     return c2py(<RCP[const symengine.Basic]>(symengine.contains(expr_.thisptr, s)))
 
 
+def set_union(*args):
+    cdef symengine.set_set s
+    cdef Set e_
+    for e in args:
+        e_ = sympify(e)
+        s.insert(e_.thisptr)
+    return c2py(<RCP[const symengine.Basic]>(symengine.set_union(s)))
+
+
+def set_intersection(*args):
+    cdef symengine.set_set s
+    cdef Set e_
+    for e in srgs:
+        e_ = sympify(e)
+        s.insert(e_.thisptr)
+    return c2py(<RCP[const symengine.Basic]>(symengine.set_intersection(s)))
+
+
+def set_complement(universe, container):
+    cdef Set universe_ = sympify(universe)
+    cdef Set container_ = sympify(container)
+    cdef RCP[const symengine.Set] u = symengine.rcp_static_cast_Set(universe_.thisptr)
+    cdef RCP[const symengine.Set] c = symengine.rcp_static_cast_Set(container_.thisptr)
+    return c2py(<RCP[const symengine.Basic]>(symengine.set_complement(u, c)))
+
+
+def set_complement_helper(container, universe):
+    cdef Set container_ = sympify(container)
+    cdef Set universe_ = sympify(universe)
+    cdef RCP[const symengine.Set] c = symengine.rcp_static_cast_Set(container_.thisptr)
+    cdef RCP[const symengine.Set] u = symengine.rcp_static_cast_Set(universe_.thisptr)
+    return c2py(<RCP[const symengine.Basic]>(symengine.set_complement_helper(c, u)))
+
+
+def conditionset(sym, condition):
+    cdef Basic sym_ = sympify(sym)
+    cdef Boolean condition_ = sympify(condition)
+    cdef RCP[const symengine.Boolean] c = symengine.rcp_static_cast_Boolean(condition_.thisptr)
+    return c2py(<RCP[const symengine.Basic]>(symengine.conditionset(sym_.thisptr, c)))
+
+
+def imageset(sym, expr, base):
+    cdef Basic sym_ = sympify(sym)
+    cdef Basic expr_ = sympify(expr)
+    cdef Set base_ = sympify(base)
+    cdef RCP[const symengine.Set] b = symengine.rcp_static_cast_Set(base_.thisptr)
+    return c2py(<RCP[const symengine.Basic]>(symengine.imageset(sym_.thisptr, expr_.thisptr, b)))
+
 # Turn on nice stacktraces:
 symengine.print_stack_on_segfault()