Merge pull request #193 from isuruf/cse2

Wrap cse

Author: isuruf

appveyor.yml

@@ -81,7 +81,8 @@ install:
 
 - set PATH=C:\Python%PYTHON_VERSION%;C:\Python%PYTHON_VERSION%\Scripts;%PATH%
 - pip install nose pytest
-- pip install --install-option="--no-cython-compile" cython
+- if [%COMPILER%]==[MinGW-w64] pip install --install-option="--no-cython-compile" cython==0.26
+- if NOT [%COMPILER%]==[MinGW-w64] pip install --install-option="--no-cython-compile" cython
 - if NOT [%WITH_NUMPY%]==[no] pip install numpy
 - if NOT [%WITH_SYMPY%]==[no] pip install sympy
 

symengine/__init__.py

@@ -11,7 +11,7 @@
         LessThan, StrictGreaterThan, StrictLessThan, Eq, Ne, Ge, Le,
         Gt, Lt, golden_ratio as GoldenRatio, catalan as Catalan,
         eulergamma as EulerGamma, Dummy, perfect_power, integer_nthroot,
-        isprime, sqrt_mod, Expr)
+        isprime, sqrt_mod, Expr, cse)
 from .utilities import var, symbols
 from .functions import *
 

symengine/lib/pywrapper.cpp

@@ -261,7 +261,7 @@ hash_t PyFunction::__hash__() const {
 bool PyFunction::__eq__(const Basic &o) const {
     if (is_a<PyFunction>(o) and
         pyfunction_class_->__eq__(*static_cast<const PyFunction &>(o).get_pyfunction_class()) and
-        unified_eq(arg_, static_cast<const PyFunction &>(o).arg_))
+        unified_eq(get_vec(), static_cast<const PyFunction &>(o).get_vec()))
         return true;
     return false;
 }
@@ -271,7 +271,7 @@ int PyFunction::compare(const Basic &o) const {
     const PyFunction &s = static_cast<const PyFunction &>(o);
     int cmp = pyfunction_class_->compare(*s.get_pyfunction_class());
     if (cmp != 0) return cmp;
-    return unified_compare(arg_, s.arg_);
+    return unified_compare(get_vec(), s.get_vec());
 }
 
 } // SymEngine

symengine/lib/symengine.pxd

@@ -219,6 +219,7 @@ cdef extern from "<symengine/basic.h>" namespace "SymEngine":
     ctypedef unordered_map[int, rcp_const_basic].iterator umap_int_basic_iterator "SymEngine::umap_int_basic::iterator"
     ctypedef unordered_map[rcp_const_basic, rcp_const_number] umap_basic_num "SymEngine::umap_basic_num"
     ctypedef unordered_map[rcp_const_basic, rcp_const_number].iterator umap_basic_num_iterator "SymEngine::umap_basic_num::iterator"
+    ctypedef vector[pair[rcp_const_basic, rcp_const_basic]] vec_pair "SymEngine::vec_pair"
 
     bool eq(const Basic &a, const Basic &b) nogil except +
     bool neq(const Basic &a, const Basic &b) nogil except +
@@ -312,6 +313,7 @@ cdef extern from "<symengine/basic.h>" namespace "SymEngine":
     bool is_a_Xor "SymEngine::is_a<SymEngine::Xor>"(const Basic &b) nogil
     RCP[const Basic] expand(RCP[const Basic] &o, bool deep) nogil except +
     void as_numer_denom(RCP[const Basic] &x, const Ptr[RCP[Basic]] &numer, const Ptr[RCP[Basic]] &denom) nogil
+    void cse(vec_pair &replacements, vec_basic &reduced_exprs, const vec_basic &exprs) nogil except +
 
 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

@@ -1,6 +1,9 @@
 from cython.operator cimport dereference as deref, preincrement as inc
 cimport symengine
-from symengine cimport RCP, pair, map_basic_basic, umap_int_basic, umap_int_basic_iterator, umap_basic_num, umap_basic_num_iterator, rcp_const_basic, std_pair_short_rcp_const_basic, rcp_const_seriescoeffinterface
+from symengine cimport (RCP, pair, map_basic_basic, umap_int_basic,
+    umap_int_basic_iterator, umap_basic_num, umap_basic_num_iterator,
+    rcp_const_basic, std_pair_short_rcp_const_basic,
+    rcp_const_seriescoeffinterface)
 from libcpp cimport bool as cppbool
 from libcpp.string cimport string
 from libcpp.vector cimport vector
@@ -751,10 +754,24 @@ def get_dict(*args):
 
 
 cdef tuple vec_basic_to_tuple(symengine.vec_basic& vec):
+    return tuple(vec_basic_to_list(vec))
+
+
+cdef list vec_basic_to_list(symengine.vec_basic& vec):
     result = []
     for i in range(vec.size()):
         result.append(c2py(<RCP[const symengine.Basic]>(vec[i])))
-    return tuple(result)
+    return result
+
+
+cdef list vec_pair_to_list(symengine.vec_pair& vec):
+    result = []
+    cdef RCP[const symengine.Basic] a, b
+    for i in range(vec.size()):
+        a = <RCP[const symengine.Basic]>vec[i].first
+        b = <RCP[const symengine.Basic]>vec[i].second
+        result.append((c2py(a), c2py(b)))
+    return result
 
 
 cdef class Basic(object):
@@ -4789,5 +4806,17 @@ def solve(f, sym, domain=None):
     return c2py(<RCP[const symengine.Basic]>(symengine.solve(f_.thisptr, x, d)))
 
 
+def cse(exprs):
+    cdef symengine.vec_basic vec
+    cdef symengine.vec_pair replacements
+    cdef symengine.vec_basic reduced_exprs
+    cdef Basic b
+    for expr in exprs:
+        b = sympify(expr)
+        vec.push_back(b.thisptr)
+    symengine.cse(replacements, reduced_exprs, vec)
+    return (vec_pair_to_list(replacements), vec_basic_to_list(reduced_exprs))
+
+
 # Turn on nice stacktraces:
 symengine.print_stack_on_segfault()

symengine/tests/test_cse.py

@@ -0,0 +1,17 @@
+from symengine import cse, sqrt, symbols
+
+def test_cse_single():
+    x, y, x0 = symbols("x, y, x0")
+    e = pow(x + y, 2) + sqrt(x + y)
+    substs, reduced = cse([e])
+    assert substs == [(x0, x + y)]
+    assert reduced == [sqrt(x0) + x0**2]
+
+
+def test_multiple_expressions():
+    w, x, y, z, x0 = symbols("w, x, y, z, x0")
+    e1 = (x + y)*z
+    e2 = (x + y)*w
+    substs, reduced = cse([e1, e2])
+    assert substs == [(x0, x + y)]
+    assert reduced == [x0*z, x0*w]

symengine_version.txt

@@ -1 +1 @@
-a2a839b5d8c4eab1560ed7ed56c805e1160344e3
+fdf132fcb4425589b69b40d60a90234944870b28