poly file name changes + making symengine mpolys inherit from a base class

.gitignore

@@ -87,16 +87,16 @@ symengine/tests/basic/test_series_expansion_UP
 symengine/tests/basic/test_series_expansion_URatP
 symengine/tests/basic/test_series_expansion_URatF
 symengine/tests/basic/test_polynomial_multivariate
-symengine/tests/polynomial/test_mexprpoly
-symengine/tests/polynomial/test_mintpoly
-symengine/tests/polynomial/test_uexprpoly
-symengine/tests/polynomial/test_uintpoly
-symengine/tests/polynomial/test_uratpoly
-symengine/tests/polynomial/test_uintpoly_flint
-symengine/tests/polynomial/test_uratpoly_flint
-symengine/tests/polynomial/test_uintpoly_piranha
-symengine/tests/polynomial/test_uratpoly_piranha
-symengine/tests/polynomial/test_basic_conversions
+symengine/tests/polys/test_mpoly_expr_symengine
+symengine/tests/polys/test_mpoly_int_symengine
+symengine/tests/polys/test_upoly_expr_symengine
+symengine/tests/polys/test_upoly_int_symengine
+symengine/tests/polys/test_upoly_rat_symengine
+symengine/tests/polys/test_upoly_int_flint
+symengine/tests/polys/test_upoly_rat_flint
+symengine/tests/polys/test_upoly_int_piranha
+symengine/tests/polys/test_upoly_rat_piranha
+symengine/tests/polys/test_basic_conversions
 symengine/tests/basic/test_fields
 symengine/tests/basic/test_infinity
 symengine/tests/logic/test_logic

symengine/CMakeLists.txt

@@ -21,11 +21,11 @@ set(SRC
     pow.cpp
     functions.cpp
     monomials.cpp
-    polys/uintpoly.cpp
-    polys/uratpoly.cpp
-    polys/uexprpoly.cpp
+    polys/upoly_int_symengine.cpp
+    polys/upoly_rat_symengine.cpp
+    polys/upoly_expr_symengine.cpp
     polys/basic_conversions.cpp
-    polys/msymenginepoly.cpp
+    polys/mpoly_symengine.cpp
     series.cpp
     series_generic.cpp
     rings.cpp
@@ -72,7 +72,7 @@ endif()
 
 if (WITH_FLINT)
     set(SRC series_flint.cpp ${SRC})
-    set(SRC polys/uintpoly_flint.cpp ${SRC})
+    set(SRC polys/upoly_flint.cpp ${SRC})
 endif()
 
 if (WITH_ARB)
@@ -81,7 +81,7 @@ endif()
 
 if (WITH_PIRANHA)
     set(SRC series_piranha.cpp ${SRC})
-    set(SRC polys/uintpoly_piranha.cpp ${SRC})
+    set(SRC polys/upoly_piranha.cpp ${SRC})
 endif()
 
 if (WITH_LLVM)
@@ -128,14 +128,14 @@ set(HEADERS
     number.h
     parser.h
     polys/basic_conversions.h
-    polys/uexprpoly.h
-    polys/uintpoly_flint.h
-    polys/uintpoly.h
-    polys/uintpoly_piranha.h
-    polys/upolybase.h
-    polys/uratpoly.h
-    polys/usymenginepoly.h
-    polys/msymenginepoly.h
+    polys/upoly_expr_symengine.h
+    polys/upoly_flint.h
+    polys/upoly_int_symengine.h
+    polys/upoly_piranha.h
+    polys/upoly_base.h
+    polys/upoly_rat_symengine.h
+    polys/upoly_base_symengine.h
+    polys/mpoly_symengine.h
     pow.h
     printer.h
     rational.h

symengine/fields.cpp

@@ -71,8 +71,9 @@ GaloisField::from_vec(const RCP<const Basic> &var,
                                        GaloisFieldDict::from_vec(v, modulo));
 }
 
-RCP<const GaloisField> GaloisField::from_uintpoly(const UIntPoly &a,
-                                                  const integer_class &modulo)
+RCP<const GaloisField>
+GaloisField::from_upoly_int_symengine(const UIntPoly &a,
+                                      const integer_class &modulo)
 {
     GaloisFieldDict wrapper(a.get_poly().get_dict(), modulo);
     return GaloisField::from_dict(a.get_var(), std::move(wrapper));

symengine/fields.h

@@ -7,8 +7,8 @@
 
 #include <symengine/basic.h>
 #include <symengine/dict.h>
-#include <symengine/polys/upolybase.h>
-#include <symengine/polys/uintpoly.h>
+#include <symengine/polys/upoly_base.h>
+#include <symengine/polys/upoly_int_symengine.h>
 
 namespace SymEngine
 {
@@ -569,8 +569,8 @@ class GaloisField : public UIntPolyBase<GaloisFieldDict, GaloisField>
     static RCP<const GaloisField> from_vec(const RCP<const Basic> &var,
                                            const std::vector<integer_class> &v,
                                            const integer_class &modulo);
-    static RCP<const GaloisField> from_uintpoly(const UIntPoly &a,
-                                                const integer_class &modulo);
+    static RCP<const GaloisField>
+    from_upoly_int_symengine(const UIntPoly &a, const integer_class &modulo);
 
     integer_class eval(const integer_class &x) const
     {

symengine/polys/mpoly_base.h

@@ -0,0 +1,51 @@
+#ifndef SYMENGINE_MULTIVARIATE
+#define SYMENGINE_MULTIVARIATE
+
+#include <symengine/basic.h>
+
+namespace SymEngine
+{
+
+template <typename Container, typename Poly>
+class MPolyBase : public Basic
+{
+private:
+    Container poly_;
+    set_basic vars_;
+
+public:
+    typedef Container container_type;
+    typedef typename Container::coef_type coef_type;
+
+    MPolyBase(const set_basic &vars, Container &&dict)
+        : poly_{dict}, vars_{vars}
+    {
+    }
+
+    static RCP<const Poly> from_container(const set_basic &vars, Container &&d)
+    {
+        return make_rcp<const Poly>(vars, std::move(d));
+    }
+
+    //! \returns `-1`,`0` or `1` after comparing
+    virtual int compare(const Basic &o) const = 0;
+    virtual hash_t __hash__() const = 0;
+
+    inline vec_basic get_args() const
+    {
+        return {};
+    }
+
+    inline const Container &get_poly() const
+    {
+        return poly_;
+    }
+
+    inline const set_basic &get_vars() const
+    {
+        return vars_;
+    }
+};
+}
+
+#endif

symengine/polys/msymenginepoly.cpp → symengine/polys/mpoly_symengine.cpp

@@ -1,4 +1,4 @@
-#include <symengine/polys/msymenginepoly.h>
+#include <symengine/polys/mpoly_symengine.h>
 
 namespace SymEngine
 {

symengine/polys/msymenginepoly.h → symengine/polys/mpoly_symengine.h

@@ -1,10 +1,11 @@
 #ifndef SYMENGINE_POLYNOMIALS_MULTIVARIATE
 #define SYMENGINE_POLYNOMIALS_MULTIVARIATE
 
+#include <symengine/polys/mpoly_base.h>
 #include <symengine/expression.h>
 #include <symengine/monomials.h>
-#include <symengine/polys/uintpoly.h>
-#include <symengine/polys/uexprpoly.h>
+#include <symengine/polys/upoly_int_symengine.h>
+#include <symengine/polys/upoly_expr_symengine.h>
 #include <symengine/symengine_casts.h>
 
 namespace SymEngine
@@ -330,24 +331,15 @@ class MExprDict : public UDictWrapper<vec_int, Expression, MExprDict>
 };
 
 template <typename Container, typename Poly>
-class MSymEnginePoly : public Basic
+class MSymEnginePoly : public MPolyBase<Container, Poly>
 {
-private:
-    Container poly_;
-    set_basic vars_;
-
 public:
     typedef Container container_type;
     typedef typename Container::coef_type coef_type;
 
     MSymEnginePoly(const set_basic &vars, Container &&dict)
-        : poly_{dict}, vars_{vars}
-    {
-    }
-
-    static RCP<const Poly> from_container(const set_basic &vars, Container &&d)
+        : MPolyBase<Container, Poly>(vars, std::move(dict))
     {
-        return make_rcp<const Poly>(vars, std::move(d));
     }
 
     int compare(const Basic &o) const
@@ -356,16 +348,18 @@ class MSymEnginePoly : public Basic
 
         const Poly &s = down_cast<const Poly &>(o);
 
-        if (vars_.size() != s.vars_.size())
-            return vars_.size() < s.vars_.size() ? -1 : 1;
-        if (poly_.dict_.size() != s.poly_.dict_.size())
-            return poly_.dict_.size() < s.poly_.dict_.size() ? -1 : 1;
+        if (this->get_vars().size() != s.get_vars().size())
+            return this->get_vars().size() < s.get_vars().size() ? -1 : 1;
+        if (this->get_poly().dict_.size() != s.get_poly().dict_.size())
+            return this->get_poly().dict_.size() < s.get_poly().dict_.size()
+                       ? -1
+                       : 1;
 
-        int cmp = unified_compare(vars_, s.vars_);
+        int cmp = unified_compare(this->get_vars(), s.get_vars());
         if (cmp != 0)
             return cmp;
 
-        return unified_compare(poly_.dict_, s.poly_.dict_);
+        return unified_compare(this->get_poly().dict_, s.get_poly().dict_);
     }
 
     template <typename FromPoly>
@@ -412,48 +406,50 @@ class MSymEnginePoly : public Basic
         return Container(std::move(d), numeric_cast<unsigned>(s.size()));
     }
 
-    inline vec_basic get_args() const
-    {
-        return {};
-    }
-
-    inline const Container &get_poly() const
-    {
-        return poly_;
-    }
-
-    inline const set_basic &get_vars() const
-    {
-        return vars_;
-    }
-
     bool __eq__(const Basic &o) const
     {
         // TODO : fix for when vars are different, but there is an intersection
         if (not is_a<Poly>(o))
             return false;
         const Poly &o_ = down_cast<const Poly &>(o);
         // compare constants without regards to vars
-        if (1 == poly_.dict_.size() && 1 == o_.poly_.dict_.size()) {
-            if (poly_.dict_.begin()->second != o_.poly_.dict_.begin()->second)
+        if (1 == this->get_poly().dict_.size()
+            && 1 == o_.get_poly().dict_.size()) {
+            if (this->get_poly().dict_.begin()->second
+                != o_.get_poly().dict_.begin()->second)
                 return false;
-            if (poly_.dict_.begin()->first == o_.poly_.dict_.begin()->first
-                && unified_eq(vars_, o_.vars_))
+            if (this->get_poly().dict_.begin()->first
+                    == o_.get_poly().dict_.begin()->first
+                && unified_eq(this->get_vars(), o_.get_vars()))
                 return true;
             typename Container::vec_type v1, v2;
-            v1.resize(vars_.size(), 0);
-            v2.resize(o_.vars_.size(), 0);
-            if (poly_.dict_.begin()->first == v1
-                || o_.poly_.dict_.begin()->first == v2)
+            v1.resize(this->get_vars().size(), 0);
+            v2.resize(o_.get_vars().size(), 0);
+            if (this->get_poly().dict_.begin()->first == v1
+                || o_.get_poly().dict_.begin()->first == v2)
                 return true;
             return false;
-        } else if (0 == poly_.dict_.size() && 0 == o_.poly_.dict_.size()) {
+        } else if (0 == this->get_poly().dict_.size()
+                   && 0 == o_.get_poly().dict_.size()) {
             return true;
         } else {
-            return (unified_eq(vars_, o_.vars_)
-                    && unified_eq(poly_.dict_, o_.poly_.dict_));
+            return (unified_eq(this->get_vars(), o_.get_vars())
+                    && unified_eq(this->get_poly().dict_, o_.get_poly().dict_));
         }
     }
+
+    static set_basic get_translated_container(Container &x, Container &y,
+                                              const Poly &a, const Poly &b)
+    {
+        vec_uint v1, v2;
+        set_basic s;
+
+        unsigned int sz = reconcile(v1, v2, s, a.get_vars(), b.get_vars());
+        x = a.get_poly().translate(v1, sz);
+        y = b.get_poly().translate(v2, sz);
+
+        return s;
+    }
 };
 
 class MIntPoly : public MSymEnginePoly<MIntDict, MIntPoly>
@@ -498,25 +494,11 @@ class MExprPoly : public MSymEnginePoly<MExprDict, MExprPoly>
 unsigned int reconcile(vec_uint &v1, vec_uint &v2, set_basic &s,
                        const set_basic &s1, const set_basic &s2);
 
-template <typename Poly, typename Container>
-set_basic get_translated_container(Container &x, Container &y, const Poly &a,
-                                   const Poly &b)
-{
-    vec_uint v1, v2;
-    set_basic s;
-
-    unsigned int sz = reconcile(v1, v2, s, a.get_vars(), b.get_vars());
-    x = a.get_poly().translate(v1, sz);
-    y = b.get_poly().translate(v2, sz);
-
-    return s;
-}
-
 template <typename Poly>
 RCP<const Poly> add_mpoly(const Poly &a, const Poly &b)
 {
     typename Poly::container_type x, y;
-    set_basic s = get_translated_container(x, y, a, b);
+    set_basic s = Poly::get_translated_container(x, y, a, b);
     x += y;
     return Poly::from_container(s, std::move(x));
 }
@@ -525,7 +507,7 @@ template <typename Poly>
 RCP<const Poly> sub_mpoly(const Poly &a, const Poly &b)
 {
     typename Poly::container_type x, y;
-    set_basic s = get_translated_container(x, y, a, b);
+    set_basic s = Poly::get_translated_container(x, y, a, b);
     x -= y;
     return Poly::from_container(s, std::move(x));
 }
@@ -534,7 +516,7 @@ template <typename Poly>
 RCP<const Poly> mul_mpoly(const Poly &a, const Poly &b)
 {
     typename Poly::container_type x, y;
-    set_basic s = get_translated_container(x, y, a, b);
+    set_basic s = Poly::get_translated_container(x, y, a, b);
     x *= y;
     return Poly::from_container(s, std::move(x));
 }

symengine/polys/usymenginepoly.h → symengine/polys/upoly_base_symengine.h

@@ -1,7 +1,7 @@
 #ifndef SYMENGINE_USYMENGINEPOLY_H
 #define SYMENGINE_USYMENGINEPOLY_H
 
-#include <symengine/polys/upolybase.h>
+#include <symengine/polys/upoly_base.h>
 
 namespace SymEngine
 {

symengine/polys/uexprpoly.h → symengine/polys/upoly_expr_symengine.h

@@ -7,7 +7,7 @@
 
 #include <symengine/expression.h>
 #include <symengine/monomials.h>
-#include <symengine/polys/usymenginepoly.h>
+#include <symengine/polys/upoly_base_symengine.h>
 
 namespace SymEngine
 {

symengine/polys/uintpoly_flint.cpp → symengine/polys/upoly_flint.cpp

@@ -1,5 +1,5 @@
 #include <symengine/symbol.h>
-#include <symengine/polys/uintpoly_flint.h>
+#include <symengine/polys/upoly_flint.h>
 
 namespace SymEngine
 {