feat(arb): add arb_get_simplest_fmpq

Set res to the rational p/q in lowest terms with smallest positive
denominator q lying in the closed real interval represented by b.
Among rationals with the smallest denominator, returns the one with
smallest absolute numerator (0/1 if 0 lies in b).

Exact balls (radius 0) take a fast path returning the midpoint
directly. Otherwise the implementation extracts the exact dyadic
endpoints of b as fmpq_t and delegates to fmpq_simplest_between,
handling the zero-crossing and fully-negative cases explicitly so
the tie-break agrees with the contract (smallest absolute numerator,
not smallest value).

Author: edgarcosta

doc/source/arb.rst

@@ -558,6 +558,24 @@ Radius and interval operations
     in swapping. It is recommended to check that the midpoint of *x* is
     within a reasonable range before calling this method.
 
+.. function:: int arb_get_simplest_fmpq(fmpq_t res, const arb_t b)
+
+    Sets *res* to the rational `p/q` in lowest terms with smallest
+    positive denominator `q` contained in the closed real interval
+    represented by *b*, and returns 1. Among rationals with the smallest
+    denominator, returns the one with smallest absolute numerator (i.e.
+    closest to 0); if 0 lies in *b*, returns 0/1.
+
+    Returns 0 and leaves *res* unchanged if *b* is not finite.
+
+    Exact balls (radius 0) take the fast path of returning the
+    midpoint as a rational directly. Otherwise the implementation
+    extracts the exact dyadic endpoints of *b* as :type:`fmpq_t` and
+    delegates to :func:`fmpq_simplest_between`, after handling the
+    zero-crossing and fully-negative cases explicitly so that the
+    answer has smallest absolute numerator rather than smallest value
+    among the simplest-denominator rationals.
+
 .. function:: void arb_floor(arb_t y, const arb_t x, slong prec)
               void arb_ceil(arb_t y, const arb_t x, slong prec)
               void arb_trunc(arb_t y, const arb_t x, slong prec)

src/arb.h

@@ -338,6 +338,7 @@ int arb_contains_int(const arb_t x);
 
 void arb_get_interval_fmpz_2exp(fmpz_t a, fmpz_t b, fmpz_t exp, const arb_t x);
 int arb_get_unique_fmpz(fmpz_t z, const arb_t x);
+int arb_get_simplest_fmpq(fmpq_t res, const arb_t b);
 
 void arb_get_fmpz_mid_rad_10exp(fmpz_t mid, fmpz_t rad, fmpz_t exp, const arb_t x, slong n);
 

src/arb/get_simplest_fmpq.c

@@ -0,0 +1,84 @@
+/*
+    Copyright (C) 2026 Edgar Costa
+
+    This file is part of FLINT.
+
+    FLINT is free software: you can redistribute it and/or modify it under
+    the terms of the GNU Lesser General Public License (LGPL) as published
+    by the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.  See <https://www.gnu.org/licenses/>.
+*/
+
+#include "arb.h"
+#include "arf.h"
+#include "fmpq.h"
+
+int
+arb_get_simplest_fmpq(fmpq_t res, const arb_t b)
+{
+    arf_t lo_arf, hi_arf;
+    fmpq_t lo, hi;
+    int negate = 0;
+    int result = 0;
+
+    if (!arb_is_finite(b))
+        return 0;
+
+    /* Fast path: exact ball. The midpoint is the only element of the
+     * interval, so it is trivially the simplest rational. arf is
+     * dyadic, so arf_get_fmpq produces the canonical form exactly. */
+    if (arb_is_exact(b))
+    {
+        arf_get_fmpq(res, arb_midref(b));
+        return 1;
+    }
+
+    arf_init(lo_arf);
+    arf_init(hi_arf);
+    fmpq_init(lo);
+    fmpq_init(hi);
+
+    /* Extract exact dyadic endpoints. */
+    arb_get_lbound_arf(lo_arf, b, ARF_PREC_EXACT);
+    arb_get_ubound_arf(hi_arf, b, ARF_PREC_EXACT);
+    arf_get_fmpq(lo, lo_arf);
+    arf_get_fmpq(hi, hi_arf);
+
+    if (fmpq_cmp(lo, hi) > 0)
+        goto cleanup;
+
+    /* If the interval crosses zero, 0/1 is the simplest rational and
+     * the only one with smallest absolute numerator. We must handle
+     * this before delegating to fmpq_simplest_between: that function
+     * breaks denominator ties by smallest value (ceil(lo)), whereas
+     * our contract is smallest absolute numerator. */
+    if (fmpq_sgn(lo) <= 0 && fmpq_sgn(hi) >= 0)
+    {
+        fmpq_zero(res);
+        result = 1;
+        goto cleanup;
+    }
+
+    /* Reduce a fully negative interval to a positive one so that
+     * fmpq_simplest_between's "smallest value" tie-break agrees with
+     * our "smallest absolute numerator" contract on the original. */
+    if (fmpq_sgn(hi) < 0)
+    {
+        negate = 1;
+        fmpq_neg(lo, lo);
+        fmpq_neg(hi, hi);
+        fmpq_swap(lo, hi);
+    }
+
+    fmpq_simplest_between(res, lo, hi);
+    if (negate)
+        fmpq_neg(res, res);
+    result = 1;
+
+cleanup:
+    arf_clear(lo_arf);
+    arf_clear(hi_arf);
+    fmpq_clear(lo);
+    fmpq_clear(hi);
+    return result;
+}

src/arb/test/main.c

@@ -120,6 +120,7 @@
 #include "t-get_mpn_fixed_mod_log2.c"
 #include "t-get_mpn_fixed_mod_pi4.c"
 #include "t-get_rand_fmpq.c"
+#include "t-get_simplest_fmpq.c"
 #include "t-get_str.c"
 #include "t-get_unique_fmpz.c"
 #include "t-hurwitz_zeta.c"
@@ -328,6 +329,7 @@ test_struct tests[] =
     TEST_FUNCTION(arb_get_mpn_fixed_mod_log2),
     TEST_FUNCTION(arb_get_mpn_fixed_mod_pi4),
     TEST_FUNCTION(arb_get_rand_fmpq),
+    TEST_FUNCTION(arb_get_simplest_fmpq),
     TEST_FUNCTION(arb_get_str),
     TEST_FUNCTION(arb_get_unique_fmpz),
     TEST_FUNCTION(arb_hurwitz_zeta),