Merge pull request #118 from JuliaMath/aa/rem-round

Implement `rem` with rounding modes and make `RoundToZero` the default mode

Author: ararslan

src/Quadmath.jl

@@ -346,8 +346,26 @@ end
     Float128(@quad_ccall(@autoql(atan2)(x::Cfloat128, y::Cfloat128)::Cfloat128))
 
 Base.Integer(x::Float128) = Int(x)
-@assume_effects :foldable Base.rem(x::Float128, y::Float128) =
+@assume_effects :foldable Base.rem(x::Float128, y::Float128, ::RoundingMode{:Nearest}) =
     Float128(@quad_ccall(@autoql(remainder)(x::Cfloat128, y::Cfloat128)::Cfloat128))
+@assume_effects :foldable Base.rem(x::Float128, y::Float128, ::RoundingMode{:ToZero}=RoundToZero) =
+    Float128(@quad_ccall(@autoql(fmod)(x::Cfloat128, y::Cfloat128)::Cfloat128))
+
+if VERSION < v"1.14.0-DEV.2070"
+    # This method was copied from Julia commit 117a6c50f5e, which added a generic method.
+    # License is MIT: https://julialang.org/license.
+    function Base.rem(x::Float128, y::Float128, rnd::Union{typeof(RoundNearestTiesAway),
+                                                           typeof(RoundNearestTiesUp)})
+        r = mod(x, y)
+        isnan(r) && return r
+        if !iszero(r)
+            m, n = abs(r) < floatmax(r)/2 ? abs.((2r, y)) : abs.((r, y/2))
+            m < n && return r
+            m > n && return mod(x, -y)
+        end
+        rnd === RoundNearestTiesUp || signbit(x) == signbit(y) ? mod(x, -y) : r
+    end
+end
 
 sincos(x::Float128) = (sin(x), cos(x))
 

test/rounding.jl

@@ -308,3 +308,53 @@ end
     end
 end
 end
+
+# These tests were copied from Julia. License is MIT: https://julialang.org/license.
+@testset "rounding consistency with Base" begin
+    @test rem(prevfloat(Float128(1)), Float128(1)) == prevfloat(Float128(1))
+    @test mod(prevfloat(Float128(1)), Float128(1)) == prevfloat(Float128(1))
+end
+@testset "rem(::Float128, ::Float128, ::RoundingMode)" begin
+    T = Float128
+    @test rem(T(1), T(2), RoundToZero)  == 1
+    @test rem(T(1), T(2), RoundNearest) == 1
+    @test rem(T(1), T(2), RoundDown)    == 1
+    @test rem(T(1), T(2), RoundUp)      == -1
+    @test rem(T(1), T(2), RoundFromZero) == -1
+    @test rem(T(1), T(2), RoundNearestTiesUp) == -1
+    @test rem(T(1), T(2), RoundNearestTiesAway) == -1
+    @test rem(T(1.5), T(2), RoundToZero)  == 1.5
+    @test rem(T(1.5), T(2), RoundNearest) == -0.5
+    @test rem(T(1.5), T(2), RoundDown)    == 1.5
+    @test rem(T(1.5), T(2), RoundUp)      == -0.5
+    @test rem(T(1.5), T(2), RoundFromZero) == -0.5
+    @test rem(T(1.5), T(2), RoundNearestTiesUp) == -0.5
+    @test rem(T(1.5), T(2), RoundNearestTiesAway) == -0.5
+    @test rem(T(-1), T(2), RoundToZero)  == -1
+    @test rem(T(-1), T(2), RoundNearest) == -1
+    @test rem(T(-1), T(2), RoundDown)    == 1
+    @test rem(T(-1), T(2), RoundUp)      == -1
+    @test rem(T(-1), T(2), RoundFromZero) == 1
+    @test rem(T(-1), T(2), RoundNearestTiesUp) == -1
+    @test rem(T(-1), T(2), RoundNearestTiesAway) == 1
+    @test rem(T(-1.5), T(2), RoundToZero)  == -1.5
+    @test rem(T(-1.5), T(2), RoundNearest) == 0.5
+    @test rem(T(-1.5), T(2), RoundDown)    == 0.5
+    @test rem(T(-1.5), T(2), RoundUp)      == -1.5
+    @test rem(T(-1.5), T(2), RoundFromZero) == 0.5
+    @test rem(T(-1.5), T(2), RoundNearestTiesUp) == 0.5
+    @test rem(T(-1.5), T(2), RoundNearestTiesAway) == 0.5
+    for mode in [RoundToZero, RoundNearest, RoundDown, RoundUp, RoundFromZero, RoundNearestTiesUp, RoundNearestTiesAway]
+        @test isnan(rem(T(1), T(0), mode))
+        @test isnan(rem(T(Inf), T(2), mode))
+        @test isnan(rem(T(1), T(NaN), mode))
+        @test rem(T(4), floatmin(T) * 2, mode) == 0
+    end
+    @test isequal(rem(nextfloat(typemin(T)), T(2), RoundToZero),  -0.0)
+    @test isequal(rem(nextfloat(typemin(T)), T(2), RoundNearest), -0.0)
+    @test isequal(rem(nextfloat(typemin(T)), T(2), RoundDown),     0.0)
+    @test isequal(rem(nextfloat(typemin(T)), T(2), RoundUp),      -0.0)
+    @test isequal(rem(nextfloat(typemin(T)), T(2), RoundFromZero), 0.0)
+    @test isequal(rem(nextfloat(typemin(T)), T(2), RoundNearestTiesUp), -0.0)
+    @test isequal(rem(nextfloat(typemin(T)), T(2), RoundNearestTiesAway), 0.0)
+end