cleaning and enhancement to PolyDict

src/sage/rings/polynomial/hilbert.pyx

@@ -133,9 +133,8 @@ cdef list quotient_by_var(list L, size_t index):
     cdef list result = L[:len(L)] # creates a copy
     cdef size_t i
     for i in range(len(L)):
-        m_j = (<ETuple>PyList_GET_ITEM(L,i)).divide_by_var(index)
-        if m_j is not None:
-            result.append(m_j)
+        if (<ETuple> PyList_GET_ITEM(L, i)).get_exp(index):
+            result.append((<ETuple> PyList_GET_ITEM(L, i)).divide_by_var(index))
     return interred(result)
 
 cdef ETuple sum_from_list(list L, size_t s, size_t l):

src/sage/rings/polynomial/multi_polynomial_element.py

@@ -845,7 +845,7 @@ def __iter__(self):
         ring = self.parent()
         one = ring.base_ring().one()
         for exp in self._exponents:
-            yield (elt[exp], MPolynomial_polydict(ring, polydict.PolyDict({exp:one})))
+            yield (elt[exp], MPolynomial_polydict(ring, polydict.PolyDict({exp: one}, check=False)))
 
     def __getitem__(self, x):
         """
@@ -1459,7 +1459,7 @@ def monomials(self):
         """
         ring = self.parent()
         one = ring.base_ring().one()
-        return [MPolynomial_polydict(ring, polydict.PolyDict({m:one}))
+        return [MPolynomial_polydict(ring, polydict.PolyDict({m: one}, check=False))
                 for m in self._exponents]
 
     def constant_coefficient(self):
@@ -1708,9 +1708,9 @@ def lm(self):
             if self.is_zero():
                 return self
             R = self.parent()
-            f = self._MPolynomial_element__element.lcmt( R.term_order().greater_tuple )
+            f = self._MPolynomial_element__element.lcmt(R.term_order().greater_tuple)
             one = R.base_ring().one()
-            self.__lm = MPolynomial_polydict(R,polydict.PolyDict({f:one}))
+            self.__lm = MPolynomial_polydict(R,polydict.PolyDict({f: one}, check=False))
             return self.__lm
 
     def lc(self):
@@ -1767,8 +1767,8 @@ def lt(self):
                 return self
             R = self.parent()
             f = self._MPolynomial_element__element.dict()
-            res = self._MPolynomial_element__element.lcmt( R.term_order().greater_tuple )
-            self.__lt = MPolynomial_polydict(R, polydict.PolyDict({res:f[res]}))
+            res = self._MPolynomial_element__element.lcmt(R.term_order().greater_tuple)
+            self.__lt = MPolynomial_polydict(R, polydict.PolyDict({res: f[res]}, check=False))
             return self.__lt
 
     def __eq__(self, right):
@@ -1881,7 +1881,7 @@ def _derivative(self, var=None):
             # var is not a generator; do term-by-term differentiation recursively
             # var may be, for example, a generator of the base ring
             d = dict([(e, x._derivative(var)) for (e, x) in self.dict().items()])
-            d = polydict.PolyDict(d)
+            d = polydict.PolyDict(d, check=False)
             d.remove_zeros()
             return MPolynomial_polydict(P, d)
 
@@ -1976,7 +1976,7 @@ def integral(self, var=None):
             # var may be, for example, a generator of the base ring
             d = {e: x.integral(var)
                  for e, x in self.dict().items()}
-            d = polydict.PolyDict(d)
+            d = polydict.PolyDict(d, check=False)
             d.remove_zeros()
         else:
             # integrate w.r.t. indicated variable

src/sage/rings/polynomial/multi_polynomial_ring.py

@@ -911,11 +911,14 @@ def sum(self, terms):
             sage: sum([x*y, 2*x^2*z - 2*x*y, 1 + y + z])
             (-x + 1)*y + (2*x^2 + 1)*z + 1
         """
-        ans = self(0)
-        elt = ans.element()
+        elt = PolyDict({}, check=False)
         for t in terms:
             elt += self(t).element()
-        return ans
+        # NOTE: here we should be using self.element_class but polynomial rings are not complient
+        # with categories...
+        from sage.rings.polynomial.multi_polynomial_element import MPolynomial_polydict
+        return MPolynomial_polydict(self, elt)
+
 
 class MPolynomialRing_polydict_domain(IntegralDomain,
                                       MPolynomialRing_polydict):

src/sage/rings/polynomial/polydict.pxd

@@ -2,14 +2,18 @@ cdef class PolyDict:
     cdef dict __repn
 
     cdef PolyDict _new(self, dict pdict)
-    cpdef remove_zeros(self)
+    cpdef remove_zeros(self, zero_test=*)
 
 
 cdef class ETuple:
     cdef size_t _length
     cdef size_t _nonzero
     cdef int *_data
 
+    cdef size_t get_position(self, size_t i, size_t start, size_t end)
+    cdef ETuple _new(self)
+    cdef int get_exp(self, size_t i)
+
     cpdef int unweighted_degree(self) except *
     cpdef int weighted_degree(self, tuple w) except *
     cpdef int unweighted_quotient_degree(self, ETuple other) except *
@@ -22,19 +26,17 @@ cdef class ETuple:
     cpdef ETuple emax(self, ETuple other)
     cpdef ETuple eadd_p(self, int other, size_t pos)
     cpdef ETuple eadd_scaled(self, ETuple other, int scalar)
-    cpdef int dotprod(self, ETuple other)
+    cpdef int dotprod(self, ETuple other) except *
     cpdef ETuple escalar_div(self, int n)
-    cdef ETuple divide_by_gcd(self, ETuple other)
-    cdef ETuple divide_by_var(self, size_t index)
-    cdef bint divides(self, ETuple other)
+    cpdef ETuple divide_by_gcd(self, ETuple other)
+    cpdef ETuple divide_by_var(self, size_t pos)
+    cpdef bint divides(self, ETuple other) except *
     cpdef bint is_constant(self)
-    cpdef bint is_multiple_of(self, int n)
+    cpdef bint is_multiple_of(self, int n) except *
     cpdef list nonzero_positions(self, bint sort=*)
     cpdef common_nonzero_positions(self, ETuple other, bint sort=*)
     cpdef list nonzero_values(self, bint sort=*)
     cpdef ETuple reversed(self)
-    cdef ETuple _new(self)
-    cdef int get_exp(self, size_t i)
 
 cpdef int gen_index(PolyDict x)
 cpdef ETuple monomial_exponent(PolyDict p)