Deprecate setrounding

Fixes #26935.

This is the "minimal" change of deprecating Float32/Float64 support.

Author: simonbyrne

base/deprecated.jl

@@ -1669,6 +1669,11 @@ end
 @deprecate next(s::AbstractString, i::Integer) iterate(s, i)
 @deprecate done(s::AbstractString, i::Integer) i > ncodeunits(s)
 
+function Rounding.setrounding(::Type{T}, r::RoundingMode) where {T<:Union{Float32,Float64}}
+    depwarn("""`setrounding` for `Float32` and `Float64` has been deprecated, and will not be available in future versions.""", :setrounding)
+    Rounding.setrounding_raw(T, Rounding.to_fenv(r))
+end
+
 # END 0.7 deprecations
 
 # BEGIN 1.0 deprecations

base/rounding.jl

@@ -109,25 +109,6 @@ function from_fenv(r::Integer)
     end
 end
 
-"""
-    setrounding(T, mode)
-
-Set the rounding mode of floating point type `T`, controlling the rounding of basic
-arithmetic functions ([`+`](@ref), [`-`](@ref), [`*`](@ref),
-[`/`](@ref) and [`sqrt`](@ref)) and type conversion. Other numerical
-functions may give incorrect or invalid values when using rounding modes other than the
-default `RoundNearest`.
-
-Note that this may affect other types, for instance changing the rounding mode of
-[`Float64`](@ref) will change the rounding mode of [`Float32`](@ref).
-See [`RoundingMode`](@ref) for available modes.
-
-!!! warning
-
-    This feature is still experimental, and may give unexpected or incorrect values.
-"""
-setrounding(T::Type, mode)
-
 """
     rounding(T)
 
@@ -142,7 +123,6 @@ See [`RoundingMode`](@ref) for available modes.
 setrounding_raw(::Type{<:Union{Float32,Float64}}, i::Integer) = ccall(:fesetround, Int32, (Int32,), i)
 rounding_raw(::Type{<:Union{Float32,Float64}}) = ccall(:fegetround, Int32, ())
 
-setrounding(::Type{T}, r::RoundingMode) where {T<:Union{Float32,Float64}} = setrounding_raw(T,to_fenv(r))
 rounding(::Type{T}) where {T<:Union{Float32,Float64}} = from_fenv(rounding_raw(T))
 
 """

test/rounding.jl

@@ -19,36 +19,6 @@ using Test
         @test a - b === -c
         @test b - a === c
     end
-    @testset "RoundToZero" begin
-        setrounding(Float64,RoundToZero) do
-            @test a + b === d
-            @test - a - b === -d
-            @test a - b === -c
-            @test b - a === c
-        end
-        # Sanity check to see if we have returned to RoundNearest
-        @test a + b === 1.
-        @test - a - b === -1.
-        @test a - b == -c
-        @test b - a == c
-    end
-
-    @testset "RoundUp" begin
-        setrounding(Float64,RoundUp) do
-            @test a + b === 1.
-            @test - a - b === -d
-            @test a - b === -c
-            @test b - a === c
-        end
-    end
-    @testset "RoundDown" begin
-        setrounding(Float64,RoundDown) do
-            @test a + b === d
-            @test - a - b === -1.
-            @test a - b === -c
-            @test b - a === c
-        end
-    end
 end
 
 @testset "Float32 checks" begin
@@ -63,49 +33,24 @@ end
         @test a32 - b32 === -c32
         @test b32 - a32 === c32
     end
-    @testset "RoundToZero" begin
-        setrounding(Float32,RoundToZero) do
-            @test a32 + b32 === d32
-            @test - a32 - b32 === -d32
-            @test a32 - b32 === -c32
-            @test b32 - a32 === c32
-        end
-
-        # Sanity check to see if we have returned to RoundNearest
-        @test a32 + b32 === 1.0f0
-        @test - a32 - b32 === -1.0f0
-        @test a32 - b32 == -c32
-        @test b32 - a32 == c32
-    end
-    @testset "RoundUp" begin
-        setrounding(Float32,RoundUp) do
-            @test a32 + b32 === 1.0f0
-            @test - a32 - b32 === -d32
-            @test a32 - b32 === -c32
-            @test b32 - a32 === c32
-        end
-    end
-    @testset "RoundDown" begin
-        setrounding(Float32,RoundDown) do
-            @test a32 + b32 === d32
-            @test - a32 - b32 === -1.0f0
-            @test a32 - b32 === -c32
-            @test b32 - a32 === c32
-        end
-    end
 end
 
 @testset "convert with rounding" begin
     for v = [sqrt(2),-1/3,nextfloat(1.0),prevfloat(1.0),nextfloat(-1.0),
              prevfloat(-1.0),nextfloat(0.0),prevfloat(0.0)]
+
         pn = Float32(v,RoundNearest)
         @test pn == convert(Float32,v)
+
         pz = Float32(v,RoundToZero)
-        @test pz == setrounding(()->convert(Float32,v), Float64, RoundToZero)
+        @test abs(pz) <= abs(v) < nextfloat(abs(pz))
+        @test signbit(pz) == signbit(v)
+
         pd = Float32(v,RoundDown)
-        @test pd == setrounding(()->convert(Float32,v), Float64, RoundDown)
+        @test pd <= v < nextfloat(pd)
+
         pu = Float32(v,RoundUp)
-        @test pu == setrounding(()->convert(Float32,v), Float64, RoundUp)
+        @test prevfloat(pu) < v <= pu
 
         @test pn == pd || pn == pu
         @test v > 0 ? pz == pd : pz == pu