gr: disable some feature/tests for FLINT < 3.1

Author: oscarbenjamin

src/flint/types/_gr.pxd

@@ -64,7 +64,7 @@ from flint.flintlib.functions.gr_domains cimport (
 
     gr_ctx_init_real_qqbar,
     gr_ctx_init_complex_qqbar,
-    _gr_ctx_qqbar_set_limits,
+    # _gr_ctx_qqbar_set_limits,
 
     gr_ctx_init_real_ca,
     gr_ctx_init_complex_ca,
@@ -89,13 +89,14 @@ from flint.flintlib.functions.gr cimport (
     gr_set_str,
     gr_get_str,
     gr_set,
+    gr_set_si,
     gr_get_si,
 
     gr_zero,
     gr_one,
     gr_gen,
     gr_gens,
-    gr_gens_recursive,
+    # gr_gens_recursive,
     gr_ctx_set_gen_names,
 
     gr_i,
@@ -224,6 +225,15 @@ cdef class gr_ctx(flint_ctx):
             raise self._error(err, "Failed to parse string")
         return py_val
 
+    @cython.final
+    cdef inline gr from_si(self, slong n):
+        cdef gr py_val
+        py_val = self.new_gr()
+        err = gr_set_si(py_val.pval, n, self.ctx_t)
+        if err != GR_SUCCESS:
+            raise self._error(err, "Failed to parse string")
+        return py_val
+
     @cython.final
     cdef inline str to_str(self, val: gr):
         cdef str py_str
@@ -348,25 +358,25 @@ cdef class gr_ctx(flint_ctx):
         gr_vec_clear(gens, self.ctx_t)
         return py_gens
 
-    @cython.final
-    cdef inline list _gens_recursive(self):
-        cdef int err
-        cdef gr g
-        cdef gr_vec_t gens
-        gr_vec_init(gens, 0, self.ctx_t)
-        err = gr_gens_recursive(gens, self.ctx_t)
-        if err != GR_SUCCESS:
-            raise self._error(err, "Cannot get recursive generators")
-        length = gr_vec_length(gens, self.ctx_t)
-        py_gens = [None] * length
-        for 0 <= i < length:
-            g = self.new_gr()
-            err = gr_set(g.pval, gr_vec_entry_ptr(gens, i, self.ctx_t), self.ctx_t)
-            if err != GR_SUCCESS:
-                raise self._error(err, "Failed to copy generator.")
-            py_gens[i] = g
-        gr_vec_clear(gens, self.ctx_t)
-        return py_gens
+    # @cython.final
+    # cdef inline list _gens_recursive(self):
+    #     cdef int err
+    #     cdef gr g
+    #     cdef gr_vec_t gens
+    #     gr_vec_init(gens, 0, self.ctx_t)
+    #     err = gr_gens_recursive(gens, self.ctx_t)
+    #     if err != GR_SUCCESS:
+    #         raise self._error(err, "Cannot get recursive generators")
+    #     length = gr_vec_length(gens, self.ctx_t)
+    #     py_gens = [None] * length
+    #     for 0 <= i < length:
+    #         g = self.new_gr()
+    #         err = gr_set(g.pval, gr_vec_entry_ptr(gens, i, self.ctx_t), self.ctx_t)
+    #         if err != GR_SUCCESS:
+    #             raise self._error(err, "Failed to copy generator.")
+    #         py_gens[i] = g
+    #     gr_vec_clear(gens, self.ctx_t)
+    #     return py_gens
 
 
 cdef class gr_scalar_ctx(gr_ctx):
@@ -584,7 +594,9 @@ cdef class gr_real_qqbar_ctx(gr_scalar_ctx):
         ctx.bits_limit = bits_limit
         if deg_limit != -1 or bits_limit != -1:
             # Maybe add setters for these?
-            _gr_ctx_qqbar_set_limits(ctx.ctx_t, deg_limit, bits_limit)
+            # XXX: Not available in FLINT 3.0.1
+            # _gr_ctx_qqbar_set_limits(ctx.ctx_t, deg_limit, bits_limit)
+            pass
         return ctx
 
 
@@ -603,7 +615,9 @@ cdef class gr_complex_qqbar_ctx(gr_scalar_ctx):
         ctx.bits_limit = bits_limit
         if deg_limit != -1 or bits_limit != -1:
             # Maybe add setters for these?
-            _gr_ctx_qqbar_set_limits(ctx.ctx_t, deg_limit, bits_limit)
+            # XXX: Not available in FLINT 3.0.1
+            # _gr_ctx_qqbar_set_limits(ctx.ctx_t, deg_limit, bits_limit)
+            pass
         return ctx
 
 

src/flint/types/_gr.pyx

@@ -19,7 +19,7 @@ from flint.flintlib.functions.gr_domains cimport (
     gr_ctx_is_algebraically_closed,
     gr_ctx_is_finite_characteristic,
     gr_ctx_is_ordered_ring,
-    gr_ctx_is_zero_ring,
+    # gr_ctx_is_zero_ring,
     gr_ctx_is_exact,
     gr_ctx_is_canonical,
     gr_ctx_has_real_prec,
@@ -165,10 +165,10 @@ cdef class gr_ctx(flint_ctx):
         """
         return truth_to_py(gr_ctx_is_ordered_ring(self.ctx_t))
 
-    @property
-    def is_zero_ring(self) -> bool | None:
-        """True if the domain is a zero ring (can be ``None`` if unknown)."""
-        return truth_to_py(gr_ctx_is_zero_ring(self.ctx_t))
+    # @property
+    # def is_zero_ring(self) -> bool | None:
+    #     """True if the domain is a zero ring (can be ``None`` if unknown)."""
+    #     return truth_to_py(gr_ctx_is_zero_ring(self.ctx_t))
 
     @property
     def is_exact(self) -> bool | None:
@@ -229,7 +229,10 @@ cdef class gr_ctx(flint_ctx):
         >>> ctx(2)
         2
         """
-        return self.from_str(str(arg))
+        try:
+            return self.from_str(str(arg))
+        except AssertionError:
+            return self.from_si(int(arg))
 
     def zero(self) -> gr:
         """Return the zero element of the domain.
@@ -314,11 +317,11 @@ cdef class gr_ctx(flint_ctx):
     def gen(self) -> gr:
         """Return the generator of the domain (if available).
 
-        >>> from flint.types._gr import gr_fmpzi_ctx, gr_fq_nmod_ctx
+        >>> from flint.types._gr import gr_fmpzi_ctx, gr_fq_ctx
         >>> ctx = gr_fmpzi_ctx
         >>> ctx.gen()
         I
-        >>> ctx = gr_fq_nmod_ctx.new(5, 2)
+        >>> ctx = gr_fq_ctx.new(5, 2)
         >>> ctx.gen()
         a
         """
@@ -327,23 +330,25 @@ cdef class gr_ctx(flint_ctx):
     def gens(self) -> list[gr]:
         """Return the top-level generators of the domain
 
-        >>> from flint.types._gr import gr_fmpzi_ctx, gr_gr_mpoly_ctx
-        >>> ctx = gr_gr_mpoly_ctx.new(gr_fmpzi_ctx, ['x', 'y'])
-        >>> ctx.gens()
-        [x, y]
-        >>> gr_fmpzi_ctx.gens()
-        [I]
-        >>> ctx.gens_recursive()
-        [I, x, y]
+        # XXX: Does not work with FLINT < 3.1
+
+        # >>> from flint.types._gr import gr_fmpzi_ctx, gr_gr_mpoly_ctx
+        # >>> ctx = gr_gr_mpoly_ctx.new(gr_fmpzi_ctx, ['x', 'y'])
+        # >>> ctx.gens()
+        # [x, y]
+        # >>> gr_fmpzi_ctx.gens()
+        # [I]
+        # >>> ctx.gens_recursive()
+        # [I, x, y]
         """
         return self._gens()
 
-    def gens_recursive(self) -> list[gr]:
-        """Return all generators of the domain
+    # def gens_recursive(self) -> list[gr]:
+    #     """Return all generators of the domain
 
-        See :meth:`gens` for an example.
-        """
-        return self._gens_recursive()
+    #     See :meth:`gens` for an example.
+    #     """
+    #        return self._gens_recursive()
 
 
 cdef class gr_scalar_ctx(gr_ctx):
@@ -534,8 +539,6 @@ cdef class gr_fmpz_mod_ctx(gr_scalar_ctx):
         >>> Z64 = gr_fmpz_mod_ctx.new(2**64 + 1)
         >>> Z64
         gr_fmpz_mod_ctx(18446744073709551617)
-        >>> Z64(2**64+1)
-        0
         >>> Z64(2)**64 + 2
         1
         >>> Z64.is_prime
@@ -625,21 +628,22 @@ cdef class gr_fq_nmod_ctx(gr_scalar_ctx):
     def new(p, d, name=None) -> gr_fq_nmod_ctx:
         """Create a new context for finite fields.
 
-        >>> from flint.types._gr import gr_fq_nmod_ctx
-        >>> F9 = gr_fq_nmod_ctx.new(3, 2)
-        >>> F9
-        gr_fq_nmod_ctx(3, 2)
-        >>> F9(2) + F9(3)
-        2
-        >>> F9.characteristic()
-        3
-        >>> F9.degree()
-        2
-        >>> F9.gen()
-        a
-        >>> a = F9.gen()
-        >>> (1 + a) ** 2 + a
-        a+2
+        # XXX: Does not work with FLINT < 3.1
+        # >>> from flint.types._gr import gr_fq_nmod_ctx
+        # >>> F9 = gr_fq_nmod_ctx.new(3, 2)
+        # >>> F9
+        # gr_fq_nmod_ctx(3, 2)
+        # >>> F9(2) + F9(3)
+        # 2
+        # >>> F9.characteristic()
+        # 3
+        # >>> F9.degree()
+        # 2
+        # >>> F9.gen()
+        # a
+        # >>> a = F9.gen()
+        # >>> (1 + a) ** 2 + a
+        # a+2
         """
         cdef bytes name_b
         cdef char *name_c
@@ -677,21 +681,22 @@ cdef class gr_fq_zech_ctx(gr_scalar_ctx):
     def new(p, d, name=None) -> gr_fq_zech_ctx:
         """Create a new context for finite fields with small characteristic.
 
-        >>> from flint.types._gr import gr_fq_zech_ctx
-        >>> F9 = gr_fq_zech_ctx.new(3, 2)
-        >>> F9
-        gr_fq_zech_ctx(3, 2)
-        >>> F9(2) + F9(3) # XXX: Is this correct?
-        a^4
-        >>> F9.characteristic()
-        3
-        >>> F9.degree()
-        2
-        >>> F9.gen()
-        a^1
-        >>> a = F9.gen()
-        >>> (1 + a) ** 2 + a  # doctest: +SKIP
-        a+2
+        # XXX: Does not work with FLINT < 3.1
+        # >>> from flint.types._gr import gr_fq_zech_ctx
+        # >>> F9 = gr_fq_zech_ctx.new(3, 2)
+        # >>> F9
+        # gr_fq_zech_ctx(3, 2)
+        # >>> F9(2) + F9(3) # XXX: Is this correct?
+        # a^4
+        # >>> F9.characteristic()
+        # 3
+        # >>> F9.degree()
+        # 2
+        # >>> F9.gen()
+        # a^1
+        # >>> a = F9.gen()
+        # >>> (1 + a) ** 2 + a  # doctest: +SKIP
+        # a+2
         """
         cdef bytes name_b
         cdef char *name_c
@@ -1066,22 +1071,18 @@ cdef class gr_gr_poly_ctx(gr_poly_ctx):
     def new(base_ring) -> gr_gr_poly_ctx:
         """Create a new context for dense univariate polynomial rings.
 
-        >>> from flint.types._gr import gr_fmpzi_ctx, gr_gr_poly_ctx
-        >>> ZI = gr_fmpzi_ctx
-        >>> R = gr_gr_poly_ctx.new(ZI)
+        >>> from flint.types._gr import gr_fmpz_ctx, gr_gr_poly_ctx
+        >>> Z = gr_fmpz_ctx
+        >>> R = gr_gr_poly_ctx.new(Z)
         >>> R
-        gr_gr_poly_ctx(gr_fmpzi_ctx)
+        gr_gr_poly_ctx(gr_fmpz_ctx)
         >>> R.base_ring
-        gr_fmpzi_ctx
+        gr_fmpz_ctx
         >>> R.gen()
         x
-        >>> ZI.gen()
-        I
-        >>> R.gens_recursive()
-        [I, x]
-        >>> I, x = R.gens_recursive()
-        >>> (I + x) ** 2
-        -1 + (2*I)*x + x^2
+        >>> x = R.gen()
+        >>> (1 + x) ** 2
+        1 + 2*x + x^2
         """
         return gr_gr_poly_ctx._new(base_ring)
 
@@ -1101,26 +1102,24 @@ cdef class gr_gr_mpoly_ctx(gr_mpoly_ctx):
     def new(base_ring, names, order=None) -> gr_gr_mpoly_ctx:
         """Create a new context for dense multivariate polynomial rings.
 
-        >>> from flint.types._gr import gr_fmpzi_ctx, gr_gr_mpoly_ctx
-        >>> ZI = gr_fmpzi_ctx
-        >>> R = gr_gr_mpoly_ctx.new(ZI, ['x', 'y'])
-        >>> R
-        gr_gr_mpoly_ctx(gr_fmpzi_ctx, ('x', 'y'), Ordering.lex)
-        >>> R.base_ring
-        gr_fmpzi_ctx
-        >>> R.names
-        ('x', 'y')
-        >>> R.nvars
-        2
-        >>> R.order
-        <Ordering.lex: 'lex'>
-        >>> R.gens()
-        [x, y]
-        >>> R.gens_recursive()
-        [I, x, y]
-        >>> I, x, y = R.gens_recursive()
-        >>> (I + x + y) ** 2
-        x^2 + 2*x*y + (2*I)*x + y^2 + (2*I)*y - 1
+        # >>> from flint.types._gr import gr_fmpzi_ctx, gr_gr_mpoly_ctx
+        # >>> ZI = gr_fmpzi_ctx
+        # >>> R = gr_gr_mpoly_ctx.new(ZI, ['x', 'y'])
+        # >>> R
+        # gr_gr_mpoly_ctx(gr_fmpzi_ctx, ('x', 'y'), Ordering.lex)
+        # >>> R.base_ring
+        # gr_fmpzi_ctx
+        # >>> R.names
+        # ('x', 'y')
+        # >>> R.nvars
+        # 2
+        # >>> R.order
+        # <Ordering.lex: 'lex'>
+        # >>> R.gens()
+        # [x, y]
+        # >>> I, [x, y] = ZI.gen(), R.gens()
+        # >>> (I + x + y) ** 2
+        # x^2 + 2*x*y + (2*I)*x + y^2 + (2*I)*y - 1
         """
         if order is None:
             order = Ordering.lex
@@ -1194,20 +1193,18 @@ cdef class gr_series_ctx(gr_ctx):
     def new(base_ring, prec) -> gr_series_ctx:
         """Create a new context for series with precision `n`.
 
-        >>> from flint.types._gr import gr_fmpzi_ctx, gr_series_ctx
-        >>> ZI = gr_fmpzi_ctx
-        >>> R = gr_series_ctx.new(ZI, 10)
+        >>> from flint.types._gr import gr_fmpz_ctx, gr_series_ctx
+        >>> Z = gr_fmpz_ctx
+        >>> R = gr_series_ctx.new(Z, 10)
         >>> R
-        gr_series_ctx(gr_fmpzi_ctx, 10)
+        gr_series_ctx(gr_fmpz_ctx, 10)
         >>> R.base_ring
-        gr_fmpzi_ctx
+        gr_fmpz_ctx
         >>> R.prec
         10
-        >>> R.gens_recursive()
-        [I, x]
-        >>> I, x = R.gens_recursive()
-        >>> 1 / (I - x)
-        -I - x + I*x^2 + x^3 - I*x^4 - x^5 + I*x^6 + x^7 - I*x^8 - x^9 + O(x^10)
+        >>> x = R.gen()
+        >>> 1 / (1 - x)
+        1 + x + x^2 + x^3 + x^4 + x^5 + x^6 + x^7 + x^8 + x^9 + O(x^10)
         """
         return gr_series_ctx._new(base_ring, prec)
 
@@ -1589,7 +1586,7 @@ cdef class gr(flint_scalar):
 
         >>> from flint.types._gr import gr_complex_acb_ctx
         >>> C = gr_complex_acb_ctx.new(10)
-        >>> (1 + C.i()).csgn()
+        >>> (1 + C.i()).csgn()  # doctest: +SKIP
         1
         """
         return self._csgn()