Refactor overflow issues with division

Author: omus

src/FixedPointDecimals.jl

@@ -142,31 +142,21 @@ end
 
 function /{T, f}(x::FD{T, f}, y::FD{T, f})
     powt = T(10)^f
-    quotient, remainder = fldmod(widemul(x.i, powt), widen(y.i))
-    reinterpret(FD{T, f}, T(_round_to_even(quotient, remainder, widen(y.i))))
+    quotient, remainder = fldmod(widemul(x.i, powt), y.i)
+    reinterpret(FD{T, f}, T(_round_to_even(quotient, remainder, y.i)))
 end
 
 # these functions are needed to avoid InexactError when converting from the integer type
 function /{T, f}(x::Integer, y::FD{T, f})
-    S = promote_type(typeof(x), T)
-    xi, yi = promote(x, y.i)
-
-    # The integer part of our result is x.i * 10^2f / y.i, so we need to
-    # double-widen to get a precise result.
-    powt = S(10)^f
+    powt = T(10)^f
     powtsq = widemul(powt, powt)
-    quotient, remainder = fldmod(widemul(widen(xi), powtsq), widen(widen(yi)))
-
-    reinterpret(FD{T, f},
-                T(_round_to_even(quotient, remainder, widen(widen(yi)))))
+    quotient, remainder = fldmod(widemul(x, powtsq), y.i)
+    reinterpret(FD{T, f}, T(_round_to_even(quotient, remainder, y.i)))
 end
 
 function /{T, f}(x::FD{T, f}, y::Integer)
-    S = promote_type(T, typeof(y))
-    xi, yi = promote(x.i, y)
-
-    quotient, remainder = fldmod(xi, yi)
-    reinterpret(FD{T, f}, T(_round_to_even(quotient, remainder, yi)))
+    quotient, remainder = fldmod(x.i, y)
+    reinterpret(FD{T, f}, T(_round_to_even(quotient, remainder, y)))
 end
 
 # integerification

test/runtests.jl

@@ -199,7 +199,7 @@ end
         @testset for x in keyvalues[FD2]
             @test x / one(x) == x
 
-             # signed integers using two's complement have one additional negative value
+            # signed integers using two's complement have one additional negative value
             if x < 0 && x == typemin(x)
                 @test_throws InexactError x / -one(x)
             else
@@ -268,18 +268,16 @@ end
         @test 129 / FD2(200) == FD2(0.64)
         @test -129 / FD2(200) == FD2(-0.64)
 
-        # Use of Float or BigFloat internally should not change the calculated
-        # result
+        # Use of Float or BigFloat internally should not change the calculated result
         @test round(Int, 109 / 200 * 100) == 55
         @test round(Int, BigInt(109) / 200 * 100) == 54  # Correct
 
-        x = FD{Int128,2}(1.09)
-        @test x / Int128(2) == x / BigInt(2) == FD2(0.54)
-        @test x / FD{Int128,2}(2) == x / Int128(2) == FD2(0.54)
-
-        y = FD{Int128,2}(200)
-        @test Int128(109) / y == BigInt(109) / y == FD2(0.54)
-        @test FD{Int128,2}(109) / y == Int128(109) / y == FD2(0.54)
+        x = FD2(1.09)
+        y = FD2(200)
+        for T in [FD2, Int8, Int128, BigInt]
+            @test x / T(2) == FD2(0.54)
+            @test T(109) / y == FD2(0.54)
+        end
     end
 
     @testset "without promotion" begin