Drop sequence-like indexing

Author: Jake-Moss

src/flint/flint_base/flint_base.pyx

@@ -244,6 +244,21 @@ cdef class flint_mpoly(flint_elem):
     def to_dict(self):
         return {self.exponent_tuple(i): self.coefficient(i) for i in range(len(self))}
 
+    def __contains__(self, x):
+        """
+        Returns True if `self` contains a term with exponent vector `x` and a non-zero coefficient.
+
+            >>> from flint import Ordering
+            >>> ctx = fmpq_mpoly_ctx.get_context(2, Ordering.lex, 'x')
+            >>> p = ctx.from_dict({(0, 1): 2, (1, 1): 3})
+            >>> (1, 1) in p
+            True
+            >>> (5, 1) in p
+            False
+
+        """
+        return bool(self[x])
+
 
 cdef class flint_series(flint_elem):
     """

src/flint/test/test_all.py

@@ -2746,10 +2746,8 @@ def quick_poly():
         assert raises(lambda: p.coefficient(-1), IndexError)
         assert raises(lambda: p.coefficient(10), IndexError)
 
-        assert p[0] == mpoly({(2, 2): 4})
-        assert p[3] == mpoly({(0, 0): 1})
-        assert raises(lambda: p[-1], IndexError)
-        assert raises(lambda: p[4], IndexError)
+        assert raises(lambda: p[-1], TypeError)
+        assert raises(lambda: p[4], TypeError)
 
         assert p[(2, 2)] == 4
         assert p[(0, 0)] == 1
@@ -2758,22 +2756,22 @@ def quick_poly():
         assert raises(lambda: p["bad"], TypeError)
 
         p = quick_poly()
-        p[1] = S(10)
+        p[(1, 0)] = S(10)
         assert p == mpoly({(0, 0): 1, (0, 1): 2, (1, 0): 10, (2, 2): 4})
 
         p = quick_poly()
-        p[(1, 0)] = S(10)
-        assert p == mpoly({(0, 0): 1, (0, 1): 2, (1, 0): 10, (2, 2): 4})
+        p[(1, 0)] = p[(1, 0)]
+        assert p == quick_poly()
+        assert (1, 0) in p
+        assert (100, 100) not in p
 
-        assert raises(lambda: p.__setitem__(-1, 1), IndexError)
-        assert raises(lambda: p.__setitem__(4, 1), IndexError)
+        assert raises(lambda: p.__setitem__((4,), 1), ValueError)
 
         assert raises(lambda: p.__setitem__((1,), 1), ValueError)
         assert raises(lambda: p.__setitem__((1, "bad"), 1), TypeError)
-        assert raises(lambda: p.__setitem__("bad", 1), TypeError)
+        assert raises(lambda: p.__setitem__(("bad", 1), 1), TypeError)
 
-        assert raises(lambda: p.__setitem__(2, None), TypeError)
-        assert raises(lambda: p.__setitem__(-1, 1), IndexError)
+        assert raises(lambda: p.__setitem__((2, 1), None), TypeError)
 
         assert P(ctx=ctx).repr() == f"{ctx.__class__.__name__}(2, '<Ordering.lex: 0>', ('x0', 'x1')).from_dict({{}})"
         assert P(1, ctx=ctx).repr() == f"{ctx.__class__.__name__}(2, '<Ordering.lex: 0>', ('x0', 'x1')).from_dict({{(0, 0): 1}})"

src/flint/types/fmpq_mpoly.pyx

@@ -265,69 +265,57 @@ cdef class fmpq_mpoly(flint_mpoly):
 
     def __getitem__(self, x):
         """
-        Return the term at index `x` if `x` is an `int`, or the term with the exponent
-        vector `x` if `x` is a tuple of `int`s or `fmpq`s.
+        Return the coefficient of the term with the exponent vector `x`.
+        Always returns a value, missing keys will return `0`.
+        Negative exponents are made positive.
 
             >>> from flint import Ordering
             >>> ctx = fmpq_mpoly_ctx.get_context(2, Ordering.lex, 'x')
             >>> p = ctx.from_dict({(0, 1): 2, (1, 1): 3})
-            >>> p[1]
-            2*x1
             >>> p[1, 1]
             3
 
         """
         cdef:
             slong nvars = self.ctx.nvars()
 
-        if isinstance(x, int):
-            if not 0 <= x < fmpq_mpoly_length(self.val, self.ctx.val):
-                raise IndexError("term index out of range")
-            res = create_fmpq_mpoly(self.ctx)
-            fmpq_mpoly_get_term((<fmpq_mpoly> res).val, self.val, x, self.ctx.val)
-            return res
-        elif isinstance(x, tuple):
-            if len(x) != nvars:
-                raise ValueError("exponent vector provided does not match number of variables")
-            res = fmpq()
-            exp_vec = fmpz_vec(x, double_indirect=True)
-            fmpq_mpoly_get_coeff_fmpq_fmpz((<fmpq>res).val, self.val, exp_vec.double_indirect, self.ctx.val)
-            return res
-        else:
-            raise TypeError("index is not integer or tuple")
+        if not isinstance(x, tuple):
+            raise TypeError("Exponent vector index is not a tuple")
+        elif len(x) != nvars:
+            raise ValueError("Exponent vector provided does not match number of variables")
+
+        res = fmpq()
+        exp_vec = fmpz_vec(x, double_indirect=True)
+        fmpq_mpoly_get_coeff_fmpq_fmpz((<fmpq>res).val, self.val, exp_vec.double_indirect, self.ctx.val)
+        return res
 
     def __setitem__(self, x, y):
         """
-        Set the coefficient at index `x` to `y` if `x` is an `int`, or the term with
-        the exponent vector `x` if `x` is a tuple of `int`s or `fmpq`s.
+        Set the coefficient of the term with the exponent vector `x` to `y`.
+        Will always set a value, missing keys will create a new term.
+        Negative exponents are made positive.
 
             >>> from flint import Ordering
             >>> ctx = fmpq_mpoly_ctx.get_context(2, Ordering.lex, 'x')
             >>> p = ctx.from_dict({(0, 1): 2, (1, 1): 3})
-            >>> p[1] = 10
             >>> p[1, 1] = 20
             >>> p
-            20*x0*x1 + 10*x1
+            20*x0*x1 + 2*x1
 
         """
         cdef:
             slong nvars = self.ctx.nvars()
 
         coeff = any_as_fmpq(y)
         if coeff is NotImplemented:
-            raise TypeError("provided coefficient not coercible to fmpq")
-
-        if isinstance(x, int):
-            if not 0 <= x < fmpq_mpoly_length(self.val, self.ctx.val):
-                raise IndexError("term index out of range")
-            fmpq_mpoly_set_term_coeff_fmpq(self.val, x, (<fmpq>coeff).val, self.ctx.val)
-        elif isinstance(x, tuple):
-            if len(x) != nvars:
-                raise ValueError("exponent vector provided does not match number of variables")
-            exp_vec = fmpz_vec(x, double_indirect=True)
-            fmpq_mpoly_set_coeff_fmpq_fmpz(self.val, (<fmpq>coeff).val, exp_vec.double_indirect, self.ctx.val)
-        else:
-            raise TypeError("index is not integer or tuple")
+            raise TypeError("Provided coefficient not coercible to fmpq")
+        elif not isinstance(x, tuple):
+            raise TypeError("Exponent vector index is not a tuple")
+        elif len(x) != nvars:
+            raise ValueError("Exponent vector provided does not match number of variables")
+
+        exp_vec = fmpz_vec(x, double_indirect=True)
+        fmpq_mpoly_set_coeff_fmpq_fmpz(self.val, (<fmpq>coeff).val, exp_vec.double_indirect, self.ctx.val)
 
     def __pos__(self):
         return self

src/flint/types/fmpz_mpoly.pyx

@@ -245,49 +245,42 @@ cdef class fmpz_mpoly(flint_mpoly):
 
     def __getitem__(self, x):
         """
-        Return the term at index `x` if `x` is an `int`, or the term with the exponent
-        vector `x` if `x` is a tuple of `int`s or `fmpz`s.
+        Return the coefficient of the term with the exponent vector `x`.
+        Always returns a value, missing keys will return `0`.
+        Negative exponents are made positive.
 
             >>> from flint import Ordering
             >>> ctx = fmpz_mpoly_ctx.get_context(2, Ordering.lex, 'x')
             >>> p = ctx.from_dict({(0, 1): 2, (1, 1): 3})
-            >>> p[1]
-            2*x1
             >>> p[1, 1]
             3
 
         """
         cdef:
             slong nvars = self.ctx.nvars()
 
-        if isinstance(x, int):
-            if not 0 <= x < fmpz_mpoly_length(self.val, self.ctx.val):
-                raise IndexError("term index out of range")
-            res = create_fmpz_mpoly(self.ctx)
-            fmpz_mpoly_get_term((<fmpz_mpoly> res).val, self.val, x, self.ctx.val)
-            return res
-        elif isinstance(x, tuple):
-            if len(x) != nvars:
-                raise ValueError("exponent vector provided does not match number of variables")
-            res = fmpz()
-            exp_vec = fmpz_vec(x, double_indirect=True)
-            fmpz_mpoly_get_coeff_fmpz_fmpz((<fmpz>res).val, self.val, exp_vec.double_indirect, self.ctx.val)
-            return res
-        else:
-            raise TypeError("index is not integer or tuple")
+        if not isinstance(x, tuple):
+            raise TypeError("exponent vector index is not a tuple")
+        elif len(x) != nvars:
+            raise ValueError("exponent vector provided does not match number of variables")
+
+        res = fmpz()
+        exp_vec = fmpz_vec(x, double_indirect=True)
+        fmpz_mpoly_get_coeff_fmpz_fmpz((<fmpz>res).val, self.val, exp_vec.double_indirect, self.ctx.val)
+        return res
 
     def __setitem__(self, x, y):
         """
-        Set the coefficient at index `x` to `y` if `x` is an `int`, or the term with
-        the exponent vector `x` if `x` is a tuple of `int`s or `fmpz`s.
+        Set the coefficient of the term with the exponent vector `x` to `y`.
+        Will always set a value, missing keys will create a new term.
+        Negative exponents are made positive.
 
             >>> from flint import Ordering
             >>> ctx = fmpz_mpoly_ctx.get_context(2, Ordering.lex, 'x')
             >>> p = ctx.from_dict({(0, 1): 2, (1, 1): 3})
-            >>> p[1] = 10
             >>> p[1, 1] = 20
             >>> p
-            20*x0*x1 + 10*x1
+            20*x0*x1 + 2*x1
 
         """
         cdef:
@@ -296,18 +289,13 @@ cdef class fmpz_mpoly(flint_mpoly):
         coeff = any_as_fmpz(y)
         if coeff is NotImplemented:
             raise TypeError("provided coefficient not coercible to fmpz")
+        elif not isinstance(x, tuple):
+            raise TypeError("exponent vector index is not a tuple")
+        elif len(x) != nvars:
+            raise ValueError("exponent vector provided does not match number of variables")
 
-        if isinstance(x, int):
-            if not 0 <= x < fmpz_mpoly_length(self.val, self.ctx.val):
-                raise IndexError("term index out of range")
-            fmpz_mpoly_set_term_coeff_fmpz(self.val, x, (<fmpz>coeff).val, self.ctx.val)
-        elif isinstance(x, tuple):
-            if len(x) != nvars:
-                raise ValueError("exponent vector provided does not match number of variables")
-            exp_vec = fmpz_vec(x, double_indirect=True)
-            fmpz_mpoly_set_coeff_fmpz_fmpz(self.val, (<fmpz>coeff).val, exp_vec.double_indirect, self.ctx.val)
-        else:
-            raise TypeError("index is not integer or tuple")
+        exp_vec = fmpz_vec(x, double_indirect=True)
+        fmpz_mpoly_set_coeff_fmpz_fmpz(self.val, (<fmpz>coeff).val, exp_vec.double_indirect, self.ctx.val)
 
     def __pos__(self):
         return self