Add the missing checked_ operations: fld,cld,rem,mod,abs,neg. Add tests

Author: NHDaly

README.md

@@ -74,17 +74,17 @@ ERROR: OverflowError: 1.00 ÷ 0.50 overflowed for type FixedDecimal{Int8, 2}
 **Checked division:** Note that `checked_div` performs truncating, integer division. Julia Base does not provide a function to perform checked decimal division, so we provide one in this package, `FixedPointDecimals.checked_decimal_division`.
 
 Here are all the checked arithmetic operations supported by `FixedDecimal`s:
-- `Base.checked_add`
-- `Base.checked_sub`
-- `Base.checked_mul`
-- `Base.checked_div`
-- `FixedPointDecimals.checked_decimal_division`
-- `Base.checked_cld`
-- `Base.checked_fld`
-- `Base.checked_rem`
-- `Base.checked_mod`
-- `Base.checked_neg`
-- `Base.checked_abs`
+- `Base.checked_add(x,y)`
+- `Base.checked_sub(x,y)`
+- `Base.checked_mul(x,y)`
+- `Base.checked_div(x,y)`
+- `FixedPointDecimals.checked_decimal_division(x,y)`
+- `Base.checked_cld(x,y)`
+- `Base.checked_fld(x,y)`
+- `Base.checked_rem(x,y)`
+- `Base.checked_mod(x,y)`
+- `Base.checked_neg(x)`
+- `Base.checked_abs(x)`
 
 ### Conversions, Promotions, and Inexact Errors.
 

src/FixedPointDecimals.jl

@@ -386,6 +386,10 @@ Base.checked_add(x::FD, y::FD) = Base.checked_add(promote(x, y)...)
 Base.checked_sub(x::FD, y::FD) = Base.checked_sub(promote(x, y)...)
 Base.checked_mul(x::FD, y::FD) = Base.checked_mul(promote(x, y)...)
 Base.checked_div(x::FD, y::FD) = Base.checked_div(promote(x, y)...)
+Base.checked_cld(x::FD, y::FD) = Base.checked_cld(promote(x, y)...)
+Base.checked_fld(x::FD, y::FD) = Base.checked_fld(promote(x, y)...)
+Base.checked_rem(x::FD, y::FD) = Base.checked_rem(promote(x, y)...)
+Base.checked_mod(x::FD, y::FD) = Base.checked_mod(promote(x, y)...)
 
 Base.checked_add(x, y::FD) = Base.checked_add(promote(x, y)...)
 Base.checked_add(x::FD, y) = Base.checked_add(promote(x, y)...)
@@ -395,6 +399,14 @@ Base.checked_mul(x, y::FD) = Base.checked_mul(promote(x, y)...)
 Base.checked_mul(x::FD, y) = Base.checked_mul(promote(x, y)...)
 Base.checked_div(x, y::FD) = Base.checked_div(promote(x, y)...)
 Base.checked_div(x::FD, y) = Base.checked_div(promote(x, y)...)
+Base.checked_cld(x, y::FD) = Base.checked_cld(promote(x, y)...)
+Base.checked_cld(x, y::FD) = Base.checked_cld(promote(x, y)...)
+Base.checked_fld(x::FD, y) = Base.checked_fld(promote(x, y)...)
+Base.checked_fld(x, y::FD) = Base.checked_fld(promote(x, y)...)
+Base.checked_rem(x::FD, y) = Base.checked_rem(promote(x, y)...)
+Base.checked_rem(x, y::FD) = Base.checked_rem(promote(x, y)...)
+Base.checked_mod(x::FD, y) = Base.checked_mod(promote(x, y)...)
+Base.checked_mod(x, y::FD) = Base.checked_mod(promote(x, y)...)
 
 function Base.checked_add(x::T, y::T) where {T<:FD}
     z, b = Base.add_with_overflow(x.i, y.i)
@@ -413,12 +425,33 @@ function Base.checked_mul(x::FD{T,f}, y::FD{T,f}) where {T<:Integer,f}
     typemin(T) <= v <= typemax(T) || Base.Checked.throw_overflowerr_binaryop(:*, x, y)
     return reinterpret(FD{T, f}, T(v))
 end
-function Base.checked_div(x::FD{T,f}, y::FD{T,f}) where {T<:Integer,f}
-    C = coefficient(FD{T, f})
-    # Note: The div() will already throw for divide-by-zero and typemin(T) ÷ -1.
-    v, b = Base.Checked.mul_with_overflow(C, div(x.i, y.i))
-    b && Base.Checked.throw_overflowerr_binaryop(:÷, x, y)
-    return reinterpret(FD{T, f}, v)
+# Checked division functions
+for divfn in [:div, :fld, :cld]
+    @eval function Base.$(Symbol("checked_$divfn"))(x::FD{T,f}, y::FD{T,f}) where {T<:Integer,f}
+        C = coefficient(FD{T, f})
+        # Note: The div() will already throw for divide-by-zero and typemin(T) ÷ -1.
+        v, b = Base.Checked.mul_with_overflow(C, $divfn(x.i, y.i))
+        b && _throw_overflowerr_op($(QuoteNode(divfn)), x, y)
+        return reinterpret(FD{T, f}, v)
+    end
+end
+for remfn in [:rem, :mod]
+    # rem and mod already check for divide-by-zero and typemin(T) ÷ -1, so nothing to do.
+    @eval Base.$(Symbol("checked_$remfn"))(x::T, y::T) where {T <: FD} = $remfn(x, y)
+end
+
+_throw_overflowerr_op(op, x::T, y::T) where T = throw(OverflowError("$op($x, $y) overflowed for type $T"))
+
+function Base.checked_neg(x::T) where {T<:FD}
+    r = -x
+    (x<0) & (r<0) && Base.Checked.throw_overflowerr_negation(x)
+    return r
+end
+function Base.checked_abs(x::FD)
+    r = ifelse(x<0, -x, x)
+    r<0 || return r
+    msg = LazyString("checked arithmetic: cannot compute |x| for x = ", x, "::", typeof(x))
+    throw(OverflowError(msg))
 end
 
 # We introduce a new function for this since Base.Checked only supports integers, and ints

test/FixedDecimal.jl

@@ -624,11 +624,17 @@ end
         @test FD{Int8,1}(2) / Int8(20) == FD{Int8,1}(0.1)
     end
 
-    @testset "limits" begin
+    @testset "limits: overflow" begin
         @test_throws OverflowError Base.checked_add(FD{Int8,2}(1), FD{Int8,2}(1))
+        @test_throws OverflowError Base.checked_add(FD{Int8,2}(1), 1)
         @test_throws OverflowError Base.checked_add(FD{Int8,2}(1), FD{Int8,2}(0.4))
 
-        @test_throws OverflowError Base.checked_div(Int8(1), FD{Int8,2}(0.5))
+        @test_throws OverflowError Base.checked_sub(FD{Int8,2}(1), FD{Int8,2}(-1))
+        @test_throws OverflowError Base.checked_sub(1, FD{Int8,2}(-1))
+        @test_throws OverflowError Base.checked_sub(FD{Int8,2}(1), FD{Int8,2}(0.4))
+
+        @test_throws OverflowError Base.checked_div(FD{Int8,2}(1), FD{Int8,2}(0.5))
+        @test_throws OverflowError Base.checked_div(1, FD{Int8,2}(0.5))
         @test_throws OverflowError Base.checked_div(FD{Int8,2}(1), FD{Int8,2}(0.4))
 
         @testset "checked_decimal_division" begin
@@ -637,6 +643,19 @@ end
             @test checked_decimal_division(Int8(1), FD{Int8,2}(0.8)) == FD{Int8,2}(1.25)
             @test_throws OverflowError checked_decimal_division(Int8(1), FD{Int8,2}(0.7))
         end
+
+        @test_throws OverflowError Base.checked_fld(FD{Int8,2}(-1), FD{Int8,2}(0.9))
+        @test_throws OverflowError Base.checked_cld(FD{Int8,2}(-1), FD{Int8,2}(1.1))
+
+        # Rem and Mod only throw DivideError and nothing more. They can't overflow, since
+        # they can only return smaller values than the arguments.
+        @test_throws DivideError Base.checked_rem(FD{Int8,2}(-1), FD{Int8,2}(0))
+        @test_throws DivideError Base.checked_mod(FD{Int8,2}(-1), FD{Int8,2}(0))
+
+        @test_throws OverflowError Base.checked_abs(typemin(FD{Int8,2}))
+        @test_throws OverflowError Base.checked_neg(typemin(FD{Int8,2}))
+        @test Base.checked_abs(typemax(FD{Int8,2})) == FD{Int8,2}(1.27)
+        @test Base.checked_neg(typemax(FD{Int8,2})) == FD{Int8,2}(-1.27)
     end
 
     @testset "limits of $T" for T in CONTAINER_TYPES