Add nextfloat(::BigFloat, n), prevfloat(::BigFloat,n)

NEWS.md

@@ -12,7 +12,10 @@ New language features
     `findall`, `findfirst`, `argmin`/`argmax` and `findmin`/`findmax` to work with these
     objects, returning the index of matching non-missing elements in the parent ([#31008]).
 
-  * `inv(::Missing)` has now been added and returns `missing` ([#31408]).
+  * `inv(::Missing)` has now been added and returns `missing` ([#31451]).
+
+  * `nextfloat(::BigFloat, n::Integer)` and `prevfloat(::BigFloat, n::Integer)` methods
+    have been added ([#31310]).
 
 Multi-threading changes
 -----------------------
@@ -49,6 +52,9 @@ Standard library changes
 * A no-argument construct to `Ptr{T}` has been added which constructs a null pointer ([#30919])
 * `strip` now accepts a function argument in the same manner as `lstrip` and `rstrip` ([#31211])
 * `mktempdir` now accepts a `prefix` keyword argument to customize the file name ([#31230], [#22922])
+* `nextfloat(::BigFloat)` and `prevfloat(::BigFloat)` now returns a value with the same precision
+  as their argument, which means that (in particular) `nextfloat(prevfloat(x)) == x` whereas
+  previously this could result in a completely different value with a different precision ([#31310])
 
 #### LinearAlgebra
 

base/float.jl

@@ -594,7 +594,7 @@ uabs(x::BitSigned) = unsigned(abs(x))
 
 
 """
-    nextfloat(x::IEEEFloat, n::Integer)
+    nextfloat(x::AbstractFloat, n::Integer)
 
 The result of `n` iterative applications of `nextfloat` to `x` if `n >= 0`, or `-n`
 applications of `prevfloat` if `n < 0`.

base/mpfr.jl

@@ -191,6 +191,11 @@ function BigFloat(x::BigFloat, r::MPFRRoundingMode=ROUNDING_MODE[]; precision::I
     end
 end
 
+function _duplicate(x::BigFloat)
+    z = BigFloat(;precision=precision(x))
+    ccall((:mpfr_set, :libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, Int32), z, x, 0)
+    return z
+end
 
 # convert to BigFloat
 for (fJ, fC) in ((:si,:Clong), (:ui,:Culong))
@@ -889,22 +894,25 @@ isone(x::BigFloat) = x == Clong(1)
 @eval typemax(::Type{BigFloat}) = $(BigFloat(Inf))
 @eval typemin(::Type{BigFloat}) = $(BigFloat(-Inf))
 
-function nextfloat(x::BigFloat)
-    z = BigFloat()
-    ccall((:mpfr_set, :libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode),
-          z, x, ROUNDING_MODE[])
-    ccall((:mpfr_nextabove, :libmpfr), Int32, (Ref{BigFloat},), z) != 0
-    return z
+function nextfloat!(x::BigFloat, n::Integer=1)
+    signbit(n) && return prevfloat!(x, abs(n))
+    for i = 1:n
+        ccall((:mpfr_nextabove, :libmpfr), Int32, (Ref{BigFloat},), x)
+    end
+    return x
 end
 
-function prevfloat(x::BigFloat)
-    z = BigFloat()
-    ccall((:mpfr_set, :libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode),
-          z, x, ROUNDING_MODE[])
-    ccall((:mpfr_nextbelow, :libmpfr), Int32, (Ref{BigFloat},), z) != 0
-    return z
+function prevfloat!(x::BigFloat, n::Integer=1)
+    signbit(n) && return nextfloat!(x, abs(n))
+    for i = 1:n
+        ccall((:mpfr_nextbelow, :libmpfr), Int32, (Ref{BigFloat},), x)
+    end
+    return x
 end
 
+nextfloat(x::BigFloat, n::Integer=1) = n == 0 ? x : nextfloat!(_duplicate(x), n)
+prevfloat(x::BigFloat, n::Integer=1) = n == 0 ? x : prevfloat!(_duplicate(x), n)
+
 eps(::Type{BigFloat}) = nextfloat(BigFloat(1)) - BigFloat(1)
 
 floatmin(::Type{BigFloat}) = nextfloat(zero(BigFloat))
@@ -922,6 +930,9 @@ It is logically equivalent to:
     setprecision(BigFloat, old)
 
 Often used as `setprecision(T, precision) do ... end`
+
+Note: `nextfloat()`, `prevfloat()` do not use the precision mentioned by
+`setprecision`
 """
 function setprecision(f::Function, ::Type{T}, prec::Integer) where T
     old_prec = precision(T)

test/mpfr.jl

@@ -451,8 +451,21 @@ end
         @test BigFloat(nextfloat(12.12)) == nextfloat(x)
         @test BigFloat(prevfloat(12.12)) == prevfloat(x)
     end
+    x = BigFloat(12.12, 100)
+    @test nextfloat(x, 0) === x
+    @test prevfloat(x, 0) === x
+    @test nextfloat(x).prec == x.prec
+    @test prevfloat(x).prec == x.prec
+    @test nextfloat(x) == nextfloat(x, 1)
+    @test prevfloat(x) == prevfloat(x, 1)
+    @test nextfloat(x, -1) == prevfloat(x, 1)
+    @test nextfloat(x, -2) == prevfloat(x, 2)
+    @test prevfloat(x, -1) == nextfloat(x, 1)
+    @test prevfloat(x, -2) == nextfloat(x, 2)
     @test isnan(nextfloat(BigFloat(NaN)))
     @test isnan(prevfloat(BigFloat(NaN)))
+    @test isnan(nextfloat(BigFloat(NaN), 1))
+    @test isnan(prevfloat(BigFloat(NaN), 1))
 end
 # sqrt DomainError
 @test_throws DomainError sqrt(BigFloat(-1))