Framework for fixing overflow issues

When the number of decimal places `f` produces a coefficient `10^f`
which is not representable in the container type `T` we can run into
overflow issues. Additionally, if the FixedDecimal value is also large
we can also run into overflow when working with a representable
coefficient.

The new function `coefficient` provides us with a representable power of
10 which uses a type which will never overflow when multiplied by the
value.

Author: omus

src/FixedPointDecimals.jl

@@ -29,10 +29,10 @@ export FixedDecimal, RoundThrows
 
 using Compat
 
-import Base: reinterpret, zero, one, abs, sign, ==, <, <=, +, -, /, *, div,
-             rem, divrem, fld, mod, fldmod, fld1, mod1, fldmod1, isinteger,
-             typemin, typemax, realmin, realmax, print, show, string, convert, parse,
-             promote_rule, min, max, trunc, round, floor, ceil, eps, float, widemul
+import Base: reinterpret, zero, one, abs, sign, ==, <, <=, +, -, /, *, div, rem, divrem,
+             fld, mod, fldmod, fld1, mod1, fldmod1, isinteger, typemin, typemax,
+             realmin, realmax, print, show, string, convert, parse, promote_rule, min, max,
+             trunc, round, floor, ceil, eps, float, widemul, exp10
 
 import Base.Checked: checked_mul
 
@@ -283,7 +283,7 @@ function print{T, f}(io::IO, x::FD{T, f})
 
     # note: a is negative if x.i == typemin(x.i)
     s, a = sign(x.i), abs(x.i)
-    integer, fractional = divrem(a, exp10(T, f))
+    integer, fractional = divrem(a, coefficient(x))
     integer = abs(integer)  # ...but since f > 0, this is positive
     fractional = abs(fractional)
 
@@ -382,15 +382,33 @@ function parse_round{T}(::Type{T}, fractional::AbstractString, ::RoundingMode{:N
     return T(0)
 end
 
-function exp10_max{T}(::Type{T})
+
+"""
+    max_exp10(T)
+
+The highest value of `x` which does not result in an overflow when evaluating `T(10)^x`.
+"""
+function max_exp10{T <: Integer}(::Type{T})
     length(digits(typemax(T))) - 1
 end
 
-function exp10(T::Type, y::Integer)
-    while T != BigInt && exp10_max(T) < y
-        T = widen(T)
+"""
+    exp10(::Type{FD{T, f}})
+
+Compute `10^f` as an Integer without overflow. The resulting type will be an integer of type
+T or wider.
+"""
+@generated function exp10{T <: Integer, f}(::Type{FD{T, f}})
+    P = T
+    while P != BigInt && f > max_exp10(P)
+        P = widen(P)
+    end
+    quote
+        $(P(10)^f)
     end
-    T(10)^y
 end
 
+coefficient{T, f}(fd::FD{T, f}) = widen(exp10(FD{T, f}))
+value(fd::FD) = fd.i
+
 end

test/runtests.jl

@@ -2,6 +2,7 @@ using FixedPointDecimals
 import FixedPointDecimals: FD
 using Base.Test
 using Compat
+import Base.Checked: checked_mul
 
 @testset "FixedPointDecimals" begin
 
@@ -64,6 +65,20 @@ function parse_int{T, f}(::Type{FD{T, f}}, val::AbstractString; ceil::Bool=false
     reinterpret(FD{T, f}, parse(T, val[1:(f + 1)]) + T(ceil))
 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
+    container_types = [Int8, Int16, Int32, Int64, Int128]
+    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}(0))
+            @test checked_mul(powt, typemax(T)) == powt * typemax(T)
+            @test checked_mul(powt, typemin(T)) == powt * typemin(T)
+        end
+    end
+end
+
 @testset "conversion" begin
     @testset for x in keyvalues[FD2]
         @testset for T in [Rational{Int128}, WFD2, WFD4]