More compact BigFloat printing (#23382)

Author: jw3126

base/mpfr.jl

@@ -894,28 +894,63 @@ end
 
 setprecision(f::Function, precision::Integer) = setprecision(f, BigFloat, precision)
 
-function string(x::BigFloat)
-    isfinite(x) || return string(Float64(x))
-
-    # In general, the number of decimal places needed to read back the number exactly
-    # is, excluding the most significant, ceil(log(10, 2^precision(x)))
-    k = ceil(Int32, precision(x) * 0.3010299956639812)
-    lng = k + Int32(8) # Add space for the sign, the most significand digit, the dot and the exponent
-    buf = Base.StringVector(lng + 1)
-    # format strings are guaranteed to contain no NUL, so we don't use Cstring
-    lng = ccall((:mpfr_snprintf,:libmpfr), Int32, (Ptr{UInt8}, Culong, Ptr{UInt8}, Ref{BigFloat}...), buf, lng + 1, "%.Re", x)
-    if lng < k + 5 # print at least k decimal places
-        lng = ccall((:mpfr_sprintf,:libmpfr), Int32, (Ptr{UInt8}, Ptr{UInt8}, Ref{BigFloat}...), buf, "%.$(k)Re", x)
-    elseif lng > k + 8
-        buf = Base.StringVector(lng + 1)
-        lng = ccall((:mpfr_snprintf,:libmpfr), Int32, (Ptr{UInt8}, Culong, Ptr{UInt8}, Ref{BigFloat}...), buf, lng + 1, "%.Re", x)
+function string_mpfr(x::BigFloat, fmt::String)
+    buf = Base.StringVector(0)
+    s = _calculate_buffer_size!(buf, fmt, x)
+    resize!(buf, s)
+    _fill_buffer!(buf, fmt, x)
+    String(buf)
+end
+
+function _calculate_buffer_size!(buf, fmt, x::BigFloat)
+    ccall((:mpfr_snprintf,:libmpfr),
+        Int32, (Ptr{UInt8}, Culong, Ptr{UInt8}, Ptr{BigFloat}...),
+        buf, 0, fmt, &x)
+end
+
+function _fill_buffer!(buf, fmt, x::BigFloat)
+    s = length(buf)
+    # we temporarily need one more item in buffer to capture null termination
+    resize!(buf, s + 1)
+    n = ccall((:mpfr_sprintf,:libmpfr), Int32, (Ptr{UInt8}, Ptr{UInt8}, Ptr{BigFloat}...), buf, fmt, &x)
+    @assert n + 1 == length(buf)
+    @assert last(buf) == 0x00
+    resize!(buf, s)
+end
+
+function _prettify_bigfloat(s::String)::String
+    mantissa, exponent = split(s, 'e')
+    if !contains(mantissa, '.')
+        mantissa = string(mantissa, '.')
+    end
+    mantissa = rstrip(mantissa, '0')
+    if endswith(mantissa, '.')
+        mantissa = string(mantissa, '0')
     end
-    n = (1 <= x < 10 || -10 < x <= -1 || iszero(x)) ? lng - 4 : lng
-    return String(resize!(buf,n))
+    if exponent == "+00"
+        mantissa
+    else
+        string(mantissa, 'e', exponent)
+    end
+end
+
+function _string(x::BigFloat, fmt::String)::String
+    isfinite(x) || return string(Float64(x))
+    _prettify_bigfloat(string_mpfr(x, fmt))
 end
+_string(x::BigFloat) = _string(x, "%.Re")
+_string(x::BigFloat, k::Integer) = _string(x, "%.$(k)Re")
+
+string(b::BigFloat) = _string(b)
 
 print(io::IO, b::BigFloat) = print(io, string(b))
-show(io::IO, b::BigFloat) = print(io, string(b))
+function show(io::IO, b::BigFloat)
+    if get(io, :compact, false)
+        print(io, _string(b, 5))
+    else
+        print(io, _string(b))
+    end
+end
 
 # get/set exponent min/max
 get_emax() = ccall((:mpfr_get_emax, :libmpfr), Clong, ())

test/mpfr.jl

@@ -382,17 +382,14 @@ setprecision(406) do
     @test string(nextfloat(BigFloat(1))) == str
 end
 setprecision(21) do
-    @test string(zero(BigFloat)) == "0.0000000"
     @test string(parse(BigFloat, "0.1")) == "1.0000002e-01"
     @test string(parse(BigFloat, "-9.9")) == "-9.9000015"
 end
 setprecision(40) do
-    @test string(zero(BigFloat)) == "0.0000000000000"
     @test string(parse(BigFloat, "0.1")) == "1.0000000000002e-01"
     @test string(parse(BigFloat, "-9.9")) == "-9.8999999999942"
 end
 setprecision(123) do
-    @test string(zero(BigFloat)) == "0.00000000000000000000000000000000000000"
     @test string(parse(BigFloat, "0.1")) == "9.99999999999999999999999999999999999953e-02"
     @test string(parse(BigFloat, "-9.9")) == "-9.8999999999999999999999999999999999997"
 end
@@ -886,3 +883,37 @@ if MPFR.version() > v"3.1.5" || "r11590" in MPFR.version().build
         @test abs(sin(big(pi)/6) - 0.5) < ldexp(big(1.0),-1_999_000)
     end
 end
+
+@testset "show BigFloat" begin
+    function test_show_bigfloat(x::BigFloat; contains_e::Bool=true,
+        ends::String="",
+        starts::String="")
+        sx = sprint(show, x)
+        scx = sprint(showcompact, x)
+        strx = string(x)
+        @test sx == strx
+        @test length(scx) < 20
+        @test length(scx) <= length(sx)
+        @test x == parse(BigFloat, sx)
+        @test ≈(x, parse(BigFloat, scx), rtol=1e-4)
+        for s in (sx, scx)
+            @test contains(s, 'e') == contains_e
+            @test startswith(s, starts)
+            @test endswith(s, ends)
+        end
+    end
+
+    test_show_bigfloat(big"1.23456789", contains_e=false, starts="1.23")
+    test_show_bigfloat(big"-1.23456789", contains_e=false, starts="-1.23")
+    test_show_bigfloat(big"2.3457645687563543266576889678956787e10000", starts="2.345", ends="e+10000")
+    test_show_bigfloat(big"-2.3457645687563543266576889678956787e-10000", starts="-2.345", ends="e-10000")
+
+    for to_string in [string,
+        x->sprint(show, x),
+        x->sprint(showcompact,x)]
+        @test to_string(big"0.0") == "0.0"
+        @test to_string(big"-0.0") == "-0.0"
+        @test to_string(big"1.0") == "1.0"
+        @test to_string(big"-1.0") == "-1.0"
+    end
+end