Merge pull request #23388 from jw3126/big

Make printing of big(NaN) consistent #23382

Author: StefanKarpinski

base/mpfr.jl

@@ -894,30 +894,63 @@ end
 
 setprecision(f::Function, precision::Integer) = setprecision(f, BigFloat, precision)
 
-function string(x::BigFloat)
-    if isnan(x) || isinf(x)
-        return string("BigFloat(", Float64(x), ", ", precision(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
-
-    # 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)
+    mantissa = rstrip(mantissa, '0')
+    if endswith(mantissa, '.')
+        mantissa = string(mantissa, '0')
+    end
+    if exponent == "+00"
+        mantissa
+    else
+        string(mantissa, 'e', exponent)
     end
-    n = (1 <= x < 10 || -10 < x <= -1 || iszero(x)) ? lng - 4 : lng
-    return String(resize!(buf,n))
 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
@@ -880,15 +877,43 @@ for prec in (10, 100, 1000)
     end
 end
 
-setprecision(256) do
-    @test string(big(Inf)) == "BigFloat(Inf, 256)"
-    @test string(big(-Inf)) == "BigFloat(-Inf, 256)"
-    @test string(big(NaN)) == "BigFloat(NaN, 256)"
-end
-
 # issue #22758
 if MPFR.version() > v"3.1.5" || "r11590" in MPFR.version().build
     setprecision(2_000_000) do
         @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

test/numbers.jl

@@ -3029,9 +3029,14 @@ end
     end
 end
 
-@testset "compact NaN printing" begin
-    @test sprint(io->show(IOContext(io, :compact => true), NaN16)) == "NaN"
-    @test sprint(io->show(IOContext(io, :compact => true), NaN32)) == "NaN"
-    @test sprint(io->show(IOContext(io, :compact => true), NaN64)) == "NaN"
-    @test_broken sprint(io->show(IOContext(io, :compact => true), big(NaN))) == "NaN"
+@testset "printing non finite floats" for T in subtypes(AbstractFloat)
+    for (x, sx) in [(T(NaN), "NaN"),
+                    (-T(NaN), "NaN"),
+                    (T(Inf), "Inf"),
+                    (-T(Inf), "-Inf")]
+        @assert x isa T
+        @test string(x) == sx
+        @test sprint(io -> show(IOContext(io, :compact => true), x)) == sx
+        @test sprint(print, x) == sx
+    end
 end