Restricting precision based upon storage type

omus · omus · commit f1ad20eb7b94 · 2017-05-24T15:49:53.000-05:00
diff --git a/src/FixedPointDecimals.jl b/src/FixedPointDecimals.jl
@@ -72,17 +72,25 @@ for fn in [:trunc, :floor, :ceil]
 end
 
 """
-    FixedDecimal{I <: Integer, f::Int}
+    FixedDecimal{T <: Integer, f::Int}
 
-A fixed-point decimal type backed by integral type `I`, with `f` digits after
+A fixed-point decimal type backed by integral type `T`, with `f` digits after
 the decimal point stored.
 """
 immutable FixedDecimal{T <: Integer, f} <: Real
     i::T
 
-    # internal constructor
-    Base.reinterpret{T, f}(::Type{FixedDecimal{T, f}}, i::Integer) =
-        new{T, f}(i % T)
+    # inner constructor
+    function Base.reinterpret{T, f}(::Type{FixedDecimal{T, f}}, i::Integer)
+        if T != BigInt && 0 <= f <= max_exp10(T) || T == BigInt && f >= 0
+            new{T, f}(i % T)
+        else
+            throw(ArgumentError(
+                "Requested number of decimal places $f exceeds the max allowed for the " *
+                "storage type $T: [0, $(max_exp10(T))]"
+            ))
+        end
+    end
 end
 
 const FD = FixedDecimal
@@ -424,7 +432,13 @@ T or wider.
     end
 end
 
-coefficient{T, f}(::Type{FD{T, f}}) = exp10(FD{T, f})
+"""
+    coefficient(::Type{FD{T, f}}) -> T
+
+Compute `10^f` as an Integer without overflow. Note that overflow will not occur for any
+constructable `FD{T, f}`.
+"""
+coefficient{T, f}(::Type{FD{T, f}}) = T(10)^f
 coefficient{T, f}(fd::FD{T, f}) = coefficient(FD{T, f})
 value(fd::FD) = fd.i
 
diff --git a/test/runtests.jl b/test/runtests.jl
@@ -92,14 +92,12 @@ end
 # ensure that the coefficient multiplied by the highest and lowest representable values of
 # the container type do not result in overflow.
 @testset "coefficient" begin
-    for (i, T) in enumerate(CONTAINER_TYPES)
-        for j in i:length(CONTAINER_TYPES)
-            f = FixedPointDecimals.max_exp10(CONTAINER_TYPES[j])
-            powt = FixedPointDecimals.coefficient(FD{T, f})
-            @test powt % 10 == 0
-            @test checked_mul(widen(powt), typemax(T)) == widemul(powt, typemax(T))
-            @test checked_mul(widen(powt), typemin(T)) == widemul(powt, typemin(T))
-        end
+    @testset "overflow $T" for T in CONTAINER_TYPES
+        f = FixedPointDecimals.max_exp10(T)
+        powt = FixedPointDecimals.coefficient(FD{T, f})
+        @test powt % 10 == 0
+        @test checked_mul(widen(powt), typemax(T)) == widemul(powt, typemax(T))
+        @test checked_mul(widen(powt), typemin(T)) == widemul(powt, typemin(T))
     end
 end
 
@@ -143,8 +141,13 @@ end
     end
 
     @testset "limits of $T" for T in CONTAINER_TYPES
-        f = FixedPointDecimals.max_exp10(T) + 1
-        powt = FixedPointDecimals.coefficient(FD{T,f})
+        max_exp = FixedPointDecimals.max_exp10(T)
+        f = max_exp
+        powt = widen(FixedPointDecimals.coefficient(FD{T,f}))
+
+        # Smallest positive integer which is out-of-bounds for the FD
+        x = max_exp - f + 1
+        oob = T(10)^(x > 0 ? x : 0)
 
         # ideally we would just use `typemax(T)` but due to precision issues with
         # floating-point its possible the closest float will exceed `typemax(T)`.
@@ -161,7 +164,7 @@ end
         @test convert(FD{T,f}, typemax(T) // powt) == reinterpret(FD{T,f}, typemax(T))
         @test convert(FD{T,f}, typemin(T) // powt) == reinterpret(FD{T,f}, typemin(T))
 
-        @test_throws InexactError convert(FD{T,f}, T(1))
+        @test_throws InexactError convert(FD{T,f}, oob)
 
         # Converting to a floating-point
         fd = reinterpret(FD{T,f}, typemax(T))
@@ -181,24 +184,21 @@ end
         fd = reinterpret(FD{T,f}, typemin(T))
         @test convert(Rational, fd)  == typemin(T) // powt
 
-        # Adjust number of decimal places allowed so we can have `-10 < x < 10` where x is
-        # a FD{T,f}. Only needed to test `convert(::FD, ::Integer)`
-        f = FixedPointDecimals.max_exp10(T)
-        powt = FixedPointDecimals.coefficient(FD{T,f})
-
+        # The following tests require that the number of decimal places allow for
+        # `-10 < x < 10` where x is a FD{T,f}. Needed to test `convert(::FD, ::Integer)`.
         max_int = typemax(T) ÷ powt * powt
         min_int = typemin(T) ÷ powt * powt
 
         @test convert(FD{T,f}, max_int ÷ powt) == reinterpret(FD{T,f}, max_int)
         @test convert(FD{T,f}, min_int ÷ powt) == reinterpret(FD{T,f}, min_int)
 
-        @test_throws InexactError convert(FD{T,f}, max_int ÷ powt + T(1))
-        @test_throws InexactError convert(FD{T,f}, min_int ÷ powt - T(1))  # Overflows with Unsigned
+        @test_throws InexactError convert(FD{T,f}, max_int ÷ powt + oob)
+        @test_throws InexactError convert(FD{T,f}, min_int ÷ powt - oob)  # Overflows with Unsigned
     end
 
     @testset "limits from $U to $T" for T in CONTAINER_TYPES, U in CONTAINER_TYPES
-        f = FixedPointDecimals.max_exp10(T) + 1
-        g = FixedPointDecimals.max_exp10(U) + 1
+        f = FixedPointDecimals.max_exp10(T)
+        g = FixedPointDecimals.max_exp10(U)
         powt = div(
             FixedPointDecimals.coefficient(FD{T, f}),
             FixedPointDecimals.coefficient(FD{U, g}),
@@ -329,10 +329,8 @@ end
     end
 
     @testset "limits of $T" for T in CONTAINER_TYPES
-        x = FixedPointDecimals.max_exp10(T)
-        f = x + 1
-
-        scalar = reinterpret(FD{T,f}, T(10)^x)  # 0.1
+        f = FixedPointDecimals.max_exp10(T)
+        scalar = convert(FD{T,f}, 1 // 10)  # 0.1
 
         # Since multiply will round the result we'll make sure our value does not
         # always rounds down.
@@ -445,10 +443,13 @@ end
     end
 
     @testset "limits of $T" for T in CONTAINER_TYPES
-        x = FixedPointDecimals.max_exp10(T)
-        f = x + 1
+        max_exp = FixedPointDecimals.max_exp10(T)
+        f = max_exp
+        scalar = convert(FD{T,f}, 1 // 10)  # 0.1
 
-        scalar = reinterpret(FD{T,f}, T(10)^x)  # 0.1
+        # Should be outside of the bounds of a FD{T,f}
+        x = T(10)
+        @test_throws InexactError FD{T,f}(x)
 
         # Since multiply will round the result we'll make sure our value always
         # rounds down.
@@ -459,13 +460,8 @@ end
 
         @test (max_fd * scalar) / scalar == max_fd
         @test (min_fd * scalar) / scalar == min_fd
-        @test max_fd / T(2) == reinterpret(FD{T,f}, div(max_int, 2))
-        @test min_fd / T(2) == reinterpret(FD{T,f}, div(min_int, 2))
-
-        # Since the precision of `f` doesn't allow us to make a FixedDecimal >= 1
-        # there is no way testing this function without raising an exception.
-        max_fd != 0 && @test_throws InexactError T(2) / max_fd
-        min_fd != 0 && @test_throws InexactError T(2) / min_fd
+        @test max_fd / x == reinterpret(FD{T,f}, div(max_int, x))
+        @test min_fd / x == reinterpret(FD{T,f}, div(min_int, x))
     end
 end
 
@@ -486,10 +482,11 @@ end
 end
 
 @testset "isinteger" begin
-    @testset "overflow" begin
-        # Note: After overflow `Int8(10)^6 == 64`
-        @test !isinteger(reinterpret(FD{Int8,6}, 64))  # 0.000064
-    end
+    # Note: Test cannot be used unless we can construct `FD{Int8,6}`
+    # @testset "overflow" begin
+    #     # Note: After overflow `Int8(10)^6 == 64`
+    #     @test !isinteger(reinterpret(FD{Int8,6}, 64))  # 0.000064
+    # end
 
     @testset "limits of $T" for T in CONTAINER_TYPES
         f = FixedPointDecimals.max_exp10(T)
@@ -531,7 +528,7 @@ end
     end
 
     @testset "limits of $T" for T in CONTAINER_TYPES
-        f = FixedPointDecimals.max_exp10(T) + 1
+        f = FixedPointDecimals.max_exp10(T)
         powt = FixedPointDecimals.coefficient(FD{T,f})
 
         # Ideally we would just use `typemax(T)` but due to precision issues with
@@ -547,18 +544,23 @@ end
         @test round(FD{T,f}, typemax(T) // powt) == reinterpret(FD{T,f}, typemax(T))
         @test round(FD{T,f}, typemin(T) // powt) == reinterpret(FD{T,f}, typemin(T))
 
-        # Note: due to the size of `f` all values `x::FD{T,f}` are `-1 < x < 1` which means
-        # that rounding away from zero will result in an exception.
-        if round(T, typemax(T) / powt) != 0
-            @test_throws InexactError round(reinterpret(FD{T,f}, typemax(T)))
+        # Note: rounding away from zero will result in an exception.
+        max_int = typemax(T)
+        min_int = typemin(T)
+
+        max_dec = max_int / powt
+        min_dec = min_int / powt
+
+        if round(T, max_dec) == trunc(T, max_dec)
+            @test round(reinterpret(FD{T,f}, max_int)) == FD{T,f}(round(T, max_dec))
         else
-            @test round(reinterpret(FD{T,f}, typemax(T))) == zero(FD{T,f})
+            @test_throws InexactError round(reinterpret(FD{T,f}, max_int))
         end
 
-        if round(T, typemin(T) / powt) != 0
-            @test_throws InexactError round(reinterpret(FD{T,f}, typemin(T)))
+        if round(T, min_dec) == trunc(T, min_dec)
+            @test round(reinterpret(FD{T,f}, min_int)) == FD{T,f}(round(T, min_dec))
         else
-            @test round(reinterpret(FD{T,f}, typemin(T))) == zero(FD{T,f})
+            @test_throws InexactError round(reinterpret(FD{T,f}, min_int))
         end
     end
 end
@@ -608,7 +610,7 @@ end
     end
 
     @testset "limits of $T" for T in CONTAINER_TYPES
-        f = FixedPointDecimals.max_exp10(T) + 1
+        f = FixedPointDecimals.max_exp10(T)
         powt = FixedPointDecimals.coefficient(FD{T,f})
 
         # Ideally we would just use `typemax(T)` but due to precision issues with
@@ -624,9 +626,8 @@ end
         @test value(trunc(FD{T,f}, max_int / powt)) in [max_int, max_int - 1]
         @test value(trunc(FD{T,f}, min_int / powt)) in [min_int, min_int + 1]
 
-        # Note: all values `x` in FD{T,f} are -1 < x < 1
-        @test trunc(reinterpret(FD{T,f}, typemax(T))) == zero(FD{T,f})
-        @test trunc(reinterpret(FD{T,f}, typemin(T))) == zero(FD{T,f})
+        @test trunc(reinterpret(FD{T,f}, typemax(T))) == FD{T,f}(div(typemax(T), powt))
+        @test trunc(reinterpret(FD{T,f}, typemin(T))) == FD{T,f}(div(typemin(T), powt))
     end
 end
 
@@ -674,7 +675,7 @@ epsi{T}(::Type{T}) = eps(T)
     end
 
     @testset "limits of $T" for T in CONTAINER_TYPES
-        f = FixedPointDecimals.max_exp10(T) + 1
+        f = FixedPointDecimals.max_exp10(T)
         powt = FixedPointDecimals.coefficient(FD{T,f})
 
         # Ideally we would just use `typemax(T)` but due to precision issues with
@@ -695,16 +696,26 @@ epsi{T}(::Type{T}) = eps(T)
         @test value(ceil(FD{T,f}, max_dec)) in [max_int, signed(widen(max_int)) + 1]
         @test value(ceil(FD{T,f}, min_dec)) in [min_int, min_int + 1]
 
-        # Note: all values `x` in FD{T,f} are -1 < x < 1
-        @test floor(reinterpret(FD{T,f}, typemax(T))) == zero(FD{T,f})
-        if T <: Unsigned
-            @test floor(reinterpret(FD{T,f}, typemin(T))) == zero(FD{T,f})
+        # Note: rounding away from zero will result in an exception.
+        max_int = typemax(T)
+        min_int = typemin(T)
+
+        max_dec = max_int / powt
+        min_dec = min_int / powt
+
+        @test floor(reinterpret(FD{T,f}, max_int)) == FD{T,f}(floor(T, max_dec))
+        if floor(T, min_dec) == trunc(T, min_dec)
+            @test floor(reinterpret(FD{T,f}, min_int)) == FD{T,f}(floor(T, min_dec))
         else
-            @test_throws InexactError floor(reinterpret(FD{T,f}, typemin(T)))
+            @test_throws InexactError floor(reinterpret(FD{T,f}, min_int))
         end
 
-        @test_throws InexactError ceil(reinterpret(FD{T,f}, typemax(T)))
-        @test ceil(reinterpret(FD{T,f}, typemin(T))) == zero(FD{T,f})
+        if ceil(T, max_dec) == trunc(T, max_dec)
+            @test ceil(reinterpret(FD{T,f}, max_int)) == FD{T,f}(ceil(T, max_dec))
+        else
+            @test_throws InexactError ceil(reinterpret(FD{T,f}, max_int))
+        end
+        @test ceil(reinterpret(FD{T,f}, min_int)) == FD{T,f}(ceil(T, min_dec))
     end
 end
 
@@ -720,12 +731,20 @@ end
     # Displaying a decimal could be incorrect when using a decimal place precision which is
     # close to or at the limit for our storage type.
     @testset "limits of $T" for T in CONTAINER_TYPES
-        f = FixedPointDecimals.max_exp10(T) + 1
-        max_str = "0." * rpad(typemax(T), f, '0')
-        min_str = (typemin(T) < 0 ? "-" : "") * "0." * rpad(abs(widen(typemin(T))), f, '0')
+        f = FixedPointDecimals.max_exp10(T)
+
+        function fmt(val, f)
+            str = string(val)
+            neg = ""
+            if str[1] == '-'
+                neg = "-"
+                str = str[2:end]
+            end
+            return string(neg, str[1], ".", rpad(str[2:end], f, '0'))
+        end
 
-        @test string(reinterpret(FD{T,f}, typemax(T))) == max_str
-        @test string(reinterpret(FD{T,f}, typemin(T))) == min_str
+        @test string(reinterpret(FD{T,f}, typemax(T))) == fmt(typemax(T), f)
+        @test string(reinterpret(FD{T,f}, typemin(T))) == fmt(typemin(T), f)
     end
 end
 
