Incorrect rounding when converting rational to bigfloat

[lucaferranti]

julia> versioninfo()
Julia Version 1.12.0-beta1
Commit c175ace780d (2025-04-02 11:19 UTC)
Build Info:
  Official https://julialang.org release
Platform Info:
  OS: Linux (x86_64-linux-gnu)
  CPU: 12 × 12th Gen Intel(R) Core(TM) i7-1255U
  WORD_SIZE: 64
  LLVM: libLLVM-18.1.7 (ORCJIT, alderlake)
  GC: Built with stock GC
Threads: 1 default, 1 interactive, 1 GC (on 12 virtual cores)
Environment:
  JULIA_EDITOR = hx

julia> a = 1 // (big(2)^300 + 1)
1//2037035976334486086268445688409378161051468393665936250636140449354381299763336706183397377

julia> a_up = BigFloat(a, RoundUp)
4.909093465297726553095771954986275642975215512499449565111549117187105254721673e-91

julia> a_down = BigFloat(a, RoundDown)
4.909093465297726553095771954986275642975215512499449565111549117187105254721716e-91

julia> a_down > a_up
true

here the rounded down version is strictly bigger than the rounded up version. Implementation seems to be

function BigFloat(x::Rational, r::MPFRRoundingMode=rounding_raw(BigFloat); precision::Integer=_precision_with_base_2(BigFloat))
    setprecision(BigFloat, precision) do
        setrounding_raw(BigFloat, r) do
            BigFloat(numerator(x))::BigFloat / BigFloat(denominator(x))::BigFloat
        end
    end
end

I think the problem is that here BigFloat(denominator(x)) is not exact (with default 256 bits precision) and it's rounded up when computing a_up, but to correctly round up the ratio, the denominator should be rounded down.

[OlivierHnt]

function BigFloat(x::Rational, r::MPFRRoundingMode=rounding_raw(BigFloat); precision::Integer=_precision_with_base_2(BigFloat))
    r_den = _rounding_denominator(x, r)
    setprecision(BigFloat, precision) do
        setrounding_raw(BigFloat, r) do
            BigFloat(numerator(x))::BigFloat / BigFloat(denominator(x), r_den)::BigFloat
        end
    end
end

_rounding_denominator(x, r) = r
_rounding_denominator(x, r::typeof(MPFR.MPFRRoundUp)) = ifelse(x < 0, r, MPFRRoundDown)
_rounding_denominator(x, r::typeof(MPFR.MPFRRoundDown)) = ifelse(x < 0, r, MPFRRoundUp)

yield

julia> a = 1 // (big(2)^300 + 1)
1//2037035976334486086268445688409378161051468393665936250636140449354381299763336706183397377

julia> a_up = BigFloat(a, RoundUp)
4.909093465297726553095771954986275642975215512499449565111549117187105254721673e-91

julia> a_down = BigFloat(a, RoundDown)
4.909093465297726553095771954986275642975215512499449565111549117187105254721631e-91

julia> a_down < a < a_up # failure...
false

julia> b = -a
-1//2037035976334486086268445688409378161051468393665936250636140449354381299763336706183397377

julia> b_up = BigFloat(b, RoundUp)
-4.909093465297726553095771954986275642975215512499449565111549117187105254721631e-91

julia> b_down = BigFloat(b, RoundDown)
-4.909093465297726553095771954986275642975215512499449565111549117187105254721716e-91

julia> b_down < b < b_up
true

julia> a_down == -b_up
true

julia> a_up == -b_down # failure...
false

cc @nsajko

[lucaferranti]

@OlivierHnt something like this should work (not idiomatic code probably)

julia> using Base.MPFR

julia> function myBigFloat(x::Rational, r::Base.MPFR.MPFRRoundingMode=Base.MPFR.MPFRRoundNearest; precision::Integer=256)
           r_den = _opposite_round(r)
           setprecision(BigFloat, precision) do
               Base.MPFR.setrounding_raw(BigFloat, r) do
                   BigFloat(numerator(x))::BigFloat / BigFloat(denominator(x), r_den)::BigFloat
               end
           end
       end
myBigFloat (generic function with 2 methods)

julia> function _opposite_round(r::Base.MPFR.MPFRRoundingMode)
       r == MPFR.MPFRRoundUp && return MPFR.MPFRRoundDown
       r == MPFR.MPFRRoundDown && return MPFR.MPFRRoundUp
       r
       end
_opposite_round (generic function with 1 method)

julia> a = 1 // (big(2)^300 + 1);

julia> a_up = myBigFloat(a, MPFR.MPFRRoundUp)
4.909093465297726553095771954986275642975215512499449565111549117187105254721716e-91

julia> a_down = myBigFloat(a, MPFR.MPFRRoundDown)
4.909093465297726553095771954986275642975215512499449565111549117187105254721631e-91

julia> a_down < a < a_up
true

julia> b = -a;

julia> b_up = BigFloat(b, RoundUp)
-4.909093465297726553095771954986275642975215512499449565111549117187105254721631e-91

julia> b_down = BigFloat(b, RoundDown)
-4.909093465297726553095771954986275642975215512499449565111549117187105254721716e-91

julia> b_down < b < b_up
true

julia> a_down == -b_up
true

julia> a_up == -b_down
true

I think the problem in your case was the third method of _rounding_denominator was overwriting the second, as MPFRRoundingMode is an enum. Also, I don't think the ifelse should be needed, if you want to conservatively round up the fraction, denominator should be rounded down regardless of the sign

this might not be the tightest rounded up/down BigFloat of a given rational, but should at least be in the correct direction

[OlivierHnt]

Out of curiosity, is there anything missing from @lucaferranti's suggestion? We'd like to resolve #718 over at IntervalArithmetic.
(cc @oscardssmith)

[oscardssmith]

Looks good to me.