Change mpoly context constructors

Author: Jake-Moss

src/flint/flint_base/flint_base.pxd

@@ -57,8 +57,5 @@ cdef class flint_mat(flint_elem):
 cdef class flint_series(flint_elem):
     pass
 
-cpdef enum Ordering:
-    lex, deglex, degrevlex
-
-cdef ordering_t ordering_py_to_c(ordering: Ordering)
+cdef ordering_t ordering_py_to_c(ordering)
 cdef ordering_c_to_py(ordering_t ordering)

src/flint/flint_base/flint_base.pyx

@@ -7,15 +7,16 @@ from flint.flintlib.types.flint cimport (
 from flint.utils.flint_exceptions import DomainError
 from flint.flintlib.types.mpoly cimport ordering_t
 from flint.flint_base.flint_context cimport thectx
-from flint.flint_base.flint_base cimport Ordering
 from flint.utils.typecheck cimport typecheck
 cimport libc.stdlib
 
 from typing import Optional
+from collections.abc import Iterable
 from flint.utils.flint_exceptions import IncompatibleContextError
 
 from flint.types.fmpz cimport fmpz, any_as_fmpz
 
+import enum
 
 FLINT_BITS = _FLINT_BITS
 FLINT_VERSION = _FLINT_VERSION.decode("ascii")
@@ -265,21 +266,42 @@ cdef class flint_poly(flint_elem):
         raise NotImplementedError("Complex roots are not supported for this polynomial")
 
 
+class Ordering(enum.StrEnum):
+    lex = "lex"
+    deglex = "deglex"
+    degrevlex = "degrevlex"
+
+
+cdef ordering_t ordering_py_to_c(ordering):
+    if ordering == Ordering.lex:
+        return ordering_t.ORD_LEX
+    elif ordering == Ordering.deglex:
+        return ordering_t.ORD_DEGLEX
+    elif ordering == Ordering.degrevlex:
+        return ordering_t.ORD_DEGREVLEX
+
+cdef ordering_c_to_py(ordering_t ordering):
+    if ordering == ordering_t.ORD_LEX:
+        return Ordering.lex
+    elif ordering == ordering_t.ORD_DEGLEX:
+        return Ordering.deglex
+    elif ordering == ordering_t.ORD_DEGREVLEX:
+        return Ordering.degrevlex
+    else:
+        raise ValueError("unimplemented term order %d" % ordering)
+
+
 cdef class flint_mpoly_context(flint_elem):
     """
     Base class for multivariate ring contexts
     """
 
     _ctx_cache = None
 
-    def __init__(self, int nvars, names):
-        if nvars < 0:
-            raise ValueError("cannot have a negative amount of variables")
-        elif len(names) != nvars:
-            raise ValueError("number of variables must match number of variable names")
+    def __init__(self, names: Iterable[str]):
         self.py_names = tuple(name.encode("ascii") if not isinstance(name, bytes) else name for name in names)
-        self.c_names = <const char**> libc.stdlib.malloc(nvars * sizeof(const char *))
-        for i in range(nvars):
+        self.c_names = <const char**> libc.stdlib.malloc(len(names) * sizeof(const char *))
+        for i in range(len(names)):
             self.c_names[i] = self.py_names[i]
 
     def __dealloc__(self):
@@ -292,18 +314,18 @@ cdef class flint_mpoly_context(flint_elem):
     def __repr__(self):
         return f"{self.__class__.__name__}({self.nvars()}, '{repr(self.ordering())}', {self.names()})"
 
-    def name(self, long i):
+    def name(self, i: int):
         if not 0 <= i < len(self.py_names):
             raise IndexError("variable name index out of range")
         return self.py_names[i].decode("ascii")
 
-    def names(self):
+    def names(self) -> tuple[str]:
         return tuple(name.decode("ascii") for name in self.py_names)
 
     def gens(self):
         return tuple(self.gen(i) for i in range(self.nvars()))
 
-    def variable_to_index(self, var: Union[int, str]):
+    def variable_to_index(self, var: Union[int, str]) -> int:
         """Convert a variable name string or possible index to its index in the context."""
         if isinstance(var, str):
             try:
@@ -320,48 +342,55 @@ cdef class flint_mpoly_context(flint_elem):
         return i
 
     @staticmethod
-    def create_variable_names(slong nvars, names: str):
+    def create_variable_names(names: Iterable[str | tuple[str, int]]) -> tuple[str]:
         """
-        Create a tuple of variable names based on the comma separated ``names`` string.
-
-        If ``names`` contains a single value, and ``nvars`` > 1, then the variables are numbered, e.g.
+        Create a tuple of variable names based off either ``Iterable[str]``,
+        ``tuple[str, int]``, or ``Iterable[tuple[str, int]]``.
 
-            >>> flint_mpoly_context.create_variable_names(3, "x")
+            >>> flint_mpoly_context.create_variable_names([('x', 3), 'y'])
+            ('x0', 'x1', 'x2', 'y')
+            >>> flint_mpoly_context.create_variable_names(('x', 3))
             ('x0', 'x1', 'x2')
-
         """
-        nametup = tuple(name.strip() for name in names.split(','))
-        if len(nametup) != nvars:
-            if len(nametup) == 1:
-                nametup = tuple(nametup[0] + str(i) for i in range(nvars))
+        res: list[str] = []
+
+        # Provide a convenience method to avoid having to pass a nested tuple
+        if len(names) == 2 and isinstance(names[0], str) and isinstance(names[1], int):
+            names = (names,)
+
+        for name in names:
+            if isinstance(name, str):
+                res.append(name)
             else:
-                raise ValueError("number of variables does not equal number of names")
-        return nametup
+                base, num = name
+                if num < 0:
+                    raise ValueError("cannot create a negative number of variables")
+                res.extend(base + str(i) for i in range(num))
+
+        return tuple(res)
 
     @classmethod
-    def create_context_key(cls, slong nvars=1, ordering=Ordering.lex, names: Optional[str] = "x", nametup: Optional[tuple] = None):
+    def create_context_key(
+            cls,
+            names: Iterable[str | tuple[str, int]],
+            ordering: Ordering | str = Ordering.lex
+    ):
         """
-        Create a key for the context cache via the number of variables, the ordering, and
-        either a variable name string, or a tuple of variable names.
+        Create a key for the context cache via the variable names and the ordering.
         """
         # A type hint of ``ordering: Ordering`` results in the error "TypeError: an integer is required" if a Ordering
         # object is not provided. This is pretty obtuse so we check its type ourselves
-        if not isinstance(ordering, Ordering):
-            raise TypeError(f"'ordering' ('{ordering}') is not an instance of flint.Ordering")
+        # if not isinstance(ordering, Ordering):
+        #     raise TypeError(f"'ordering' ('{ordering}') is not an instance of flint.Ordering")
 
-        if nametup is not None:
-            key = nvars, ordering, nametup
-        elif nametup is None and names is not None:
-            key = nvars, ordering, cls.create_variable_names(nvars, names)
-        else:
-            raise ValueError("must provide either 'names' or 'nametup'")
-        return key
+        return cls.create_variable_names(names), Ordering(ordering) if not isinstance(ordering, Ordering) else ordering
 
     @classmethod
     def get_context(cls, *args, **kwargs):
         """
-        Retrieve a context via the number of variables, ``nvars``, the ordering, ``ordering``, and either a variable
-        name string, ``names``, or a tuple of variable names, ``nametup``.
+        Retrieve or create a context via generator names, ``names`` and the ordering, ``ordering``.
+
+        See ``create_variable_names`` for naming schemes.
         """
         key = cls.create_context_key(*args, **kwargs)
 
@@ -373,10 +402,8 @@ cdef class flint_mpoly_context(flint_elem):
     @classmethod
     def from_context(cls, ctx: flint_mpoly_context):
         return cls.get_context(
-            nvars=ctx.nvars(),
             ordering=ctx.ordering(),
-            names=None,
-            nametup=ctx.names()
+            names=ctx.names(),
         )
 
     def _any_as_scalar(self, other):
@@ -410,35 +437,29 @@ cdef class flint_mpoly_context(flint_elem):
         return self.from_dict({tuple(exp_vec): coeff})
 
 cdef class flint_mod_mpoly_context(flint_mpoly_context):
-    def __init__(self, nvars, names, prime_modulus):
-        super().__init__(nvars, names)
+    def __init__(self, names, prime_modulus):
+        super().__init__(names)
         self.__prime_modulus = <bint>prime_modulus
 
     @classmethod
     def create_context_key(
             cls,
-            slong nvars=1,
-            ordering=Ordering.lex,
-            modulus = None,
-            names: Optional[str] = "x",
-            nametup: Optional[tuple] = None,
+            names: Iterable[str | tuple[str, int]],
+            modulus,
+            ordering: Ordering | str = Ordering.lex
     ):
         """
-        Create a key for the context cache via the number of variables, the ordering, the modulus, and either a
-        variable name string, or a tuple of variable names.
+        Create a key for the context cache via the variable names, modulus, and the ordering.
         """
-        # A type hint of ``ordering: Ordering`` results in the error "TypeError: an integer is required" if a Ordering
-        # object is not provided. This is pretty obtuse so we check its type ourselves
-        if not isinstance(ordering, Ordering):
-            raise TypeError(f"'ordering' ('{ordering}') is not an instance of flint.Ordering")
+        return *super().create_context_key(names, ordering), modulus
 
-        if nametup is not None:
-            key = nvars, ordering, nametup, modulus
-        elif nametup is None and names is not None:
-            key = nvars, ordering, cls.create_variable_names(nvars, names), modulus
-        else:
-            raise ValueError("must provide either 'names' or 'nametup'")
-        return key
+    @classmethod
+    def from_context(cls, ctx: flint_mod_mpoly_context):
+        return cls.get_context(
+            names=ctx.names(),
+            modulus=ctx.modulus(),
+            ordering=ctx.ordering(),
+        )
 
     def is_prime(self):
         """
@@ -898,26 +919,3 @@ cdef class flint_mat(flint_elem):
 
     # supports mpmath conversions
     tolist = table
-
-
-cdef ordering_t ordering_py_to_c(ordering):  # Cython does not like an "Ordering" type hint here
-    if not isinstance(ordering, Ordering):
-        raise TypeError(f"'ordering' ('{ordering}') is not an instance of flint.Ordering")
-
-    if ordering == Ordering.lex:
-        return ordering_t.ORD_LEX
-    elif ordering == Ordering.deglex:
-        return ordering_t.ORD_DEGLEX
-    elif ordering == Ordering.degrevlex:
-        return ordering_t.ORD_DEGREVLEX
-
-
-cdef ordering_c_to_py(ordering_t ordering):
-    if ordering == ordering_t.ORD_LEX:
-        return Ordering.lex
-    elif ordering == ordering_t.ORD_DEGLEX:
-        return Ordering.deglex
-    elif ordering == ordering_t.ORD_DEGREVLEX:
-        return Ordering.degrevlex
-    else:
-        raise ValueError("unimplemented term order %d" % ordering)

src/flint/test/test_all.py

@@ -2859,14 +2859,10 @@ def test_mpolys():
         # division is exact or not.
         composite_characteristic = characteristic != 0 and not characteristic.is_prime()
 
-        ctx = get_context(nvars=2)
+        ctx = get_context((("x", 2),))
 
-        assert raises(lambda: get_context(nvars=2, ordering="bad"), TypeError)
-        assert raises(lambda: get_context(nvars=-1), ValueError)
-        if ctx.__class__ is flint.fmpz_mod_mpoly_ctx or ctx.__class__ is flint.nmod_mpoly_ctx:
-            assert raises(lambda: ctx.__class__(-1, flint.Ordering.lex, [], 4), ValueError)
-        else:
-            assert raises(lambda: ctx.__class__(-1, flint.Ordering.lex, []), ValueError)
+        assert raises(lambda: get_context((("x", 2),), ordering="bad"), ValueError)
+        assert raises(lambda: get_context((("x", -1),)), ValueError)
         assert raises(lambda: ctx.constant("bad"), TypeError)
         assert raises(lambda: ctx.from_dict("bad"), ValueError)
         assert raises(lambda: ctx.from_dict({(0, 0): "bad"}), TypeError)
@@ -2875,7 +2871,7 @@ def test_mpolys():
         assert raises(lambda: ctx.gen(-1), IndexError)
         assert raises(lambda: ctx.gen(10), IndexError)
 
-        assert raises(lambda: P(val=get_context(nvars=1).constant(0), ctx=ctx), IncompatibleContextError)
+        assert raises(lambda: P(val=get_context(("x",)).constant(0), ctx=ctx), IncompatibleContextError)
         assert raises(lambda: P(val={}, ctx=None), ValueError)
         assert raises(lambda: P(val={"bad": 1}, ctx=None), ValueError)
         assert raises(lambda: P(val="1", ctx=None), ValueError)
@@ -2894,10 +2890,10 @@ def quick_poly():
         assert ctx.nvars() == 2
         assert ctx.ordering() == flint.Ordering.lex
 
-        ctx1 = get_context(4)
+        ctx1 = get_context((("x", 4),))
         assert [ctx1.name(i) for i in range(4)] == ['x0', 'x1', 'x2', 'x3']
         for order in list(flint.Ordering):
-            ctx1 = get_context(4, order)
+            ctx1 = get_context((("x", 4),), ordering=order)
             assert ctx1.ordering() == order
 
         assert ctx.constant(1) == mpoly({(0, 0): 1}) == P(1, ctx=ctx)
@@ -2948,7 +2944,7 @@ def quick_poly():
         assert P({(0, 1): 3}, ctx=ctx) == ctx.from_dict({(0, 1): 3})
 
         if P is flint.fmpq_mpoly:
-            ctx_z = flint.fmpz_mpoly_ctx.get_context(2)
+            ctx_z = flint.fmpz_mpoly_ctx.get_context((("x", 2),))
             assert quick_poly() == P(ctx_z.from_dict({(0, 0): 1, (0, 1): 2, (1, 0): 3, (2, 2): 4}))
             assert P(ctx_z.from_dict({(0, 0): 1}), ctx=ctx) == P({(0, 0): 1}, ctx=ctx)
 
@@ -2997,8 +2993,8 @@ def quick_poly():
 
         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}})"
+        assert P(ctx=ctx).repr() == f"{ctx.__class__.__name__}(2, '<Ordering.lex: 'lex'>', ('x0', 'x1')).from_dict({{}})"
+        assert P(1, ctx=ctx).repr() == f"{ctx.__class__.__name__}(2, '<Ordering.lex: 'lex'>', ('x0', 'x1')).from_dict({{(0, 0): 1}})"
         assert str(quick_poly()) == repr(quick_poly()) == '4*x0^2*x1^2 + 3*x0 + 2*x1 + 1'
 
         assert p.monomial(0) == (2, 2)
@@ -3039,7 +3035,7 @@ def quick_poly():
         assert raises(lambda: p.subs({"a": 1}), ValueError)
         assert raises(lambda: p.subs({"x0": 0, "x1": 1, "x2": 2}), ValueError)
 
-        no_gens_ctx = get_context(0)
+        no_gens_ctx = get_context(tuple())
         no_gens_p = P("2", no_gens_ctx)
         assert no_gens_p.compose(ctx=ctx1).context() is ctx1
         assert raises(lambda: no_gens_p.compose(), ValueError)
@@ -3318,8 +3314,8 @@ def test_fmpz_mpoly_vec():
     for context, mpoly_vec in _all_mpoly_vecs():
         has_groebner_functions = mpoly_vec is flint.fmpz_mpoly_vec
 
-        ctx = context.get_context(nvars=2)
-        ctx1 = context.get_context(nvars=4)
+        ctx = context.get_context((("x", 2),))
+        ctx1 = context.get_context((("x", 4),))
         x, y = ctx.gens()
 
         vec = mpoly_vec(3, ctx)
@@ -3348,7 +3344,7 @@ def test_fmpz_mpoly_vec():
         assert raises(lambda: vec.__setitem__(0, ctx1.from_dict({})), IncompatibleContextError)
 
         if has_groebner_functions:
-            ctx = context.get_context(3, flint.Ordering.lex, nametup=('x', 'y', 'z'))
+            ctx = context.get_context(("x", "y", "z"))
 
             # Examples here cannibalised from
             # https://en.wikipedia.org/wiki/Gr%C3%B6bner_basis#Example_and_counterexample
@@ -3412,7 +3408,7 @@ def _all_polys_mpolys():
         yield P, S, [x, y], is_field, characteristic
 
     for P, get_context, S, is_field, characteristic in _all_mpolys():
-        ctx = get_context(2, flint.Ordering.lex, nametup=("x", "y"))
+        ctx = get_context(("x", "y"))
         x, y = ctx.gens()
         assert isinstance(x, (
             flint.fmpz_mpoly,

src/flint/types/fmpq_mpoly.pyx

@@ -98,9 +98,9 @@ cdef class fmpq_mpoly_ctx(flint_mpoly_context):
 
     _ctx_cache = _fmpq_mpoly_ctx_cache
 
-    def __init__(self, slong nvars, ordering, names):
-        fmpq_mpoly_ctx_init(self.val, nvars, ordering_py_to_c(ordering))
-        super().__init__(nvars, names)
+    def __init__(self, names, ordering):
+        super().__init__(names)
+        fmpq_mpoly_ctx_init(self.val, len(names), ordering_py_to_c(ordering))
 
     def _any_as_scalar(self, other):
         if isinstance(other, int):