Update tests to handle improved precision

Author: omus

src/FixedPointDecimals.jl

@@ -42,6 +42,7 @@ const FMAFloat = Union{Float16, Float32, Float64, BigFloat}
 
 for fn in [:trunc, :floor, :ceil]
     fnname = Symbol(fn, "mul")
+    opp_fn = fn == :floor ? :ceil : :floor
 
     @eval begin
         @doc """
@@ -67,7 +68,11 @@ for fn in [:trunc, :floor, :ceil]
         @eval function $fnname{I, T <: FMAFloat}(::Type{I}, x::T, y::T)
             a = x * y
             b = fma(x, y, -a)
-            $fn(I, a) + ifelse(isinteger(a), $fn(I, b), zero(I))
+            if signbit(b)
+                $fn(I, a) - (isinteger(a) ? $opp_fn(I, abs(b)) : zero(I))
+            else
+                $fn(I, a) + (isinteger(a) ? $fn(I, abs(b)) : zero(I))
+            end
         end
     end
 end

test/runtests.jl

@@ -4,6 +4,8 @@ using Base.Test
 using Compat
 import Base.Checked: checked_mul
 
+include("utils.jl")
+
 @testset "FixedPointDecimals" begin
 
 const SFD2 = FixedDecimal{Int16, 2}
@@ -77,6 +79,29 @@ if VERSION < v"0.6.0-dev.1849"
     Base.:/(x::UInt128, y::BigInt) = /(promote(x, y)...)
 end
 
+# Basic tests for the methods created above
+@testset "alt" begin
+    @test trunc_alt(FD2, 0.0) == FD2(0)
+    @test floor_alt(FD2, 0.0) == FD2(0)
+    @test ceil_alt(FD2,  0.0) == FD2(0)
+
+    @test trunc_alt(FD2, 2.149) == FD2(2.14)
+    @test floor_alt(FD2, 2.149) == FD2(2.14)
+    @test ceil_alt(FD2,  2.149) == FD2(2.15)
+
+    @test trunc_alt(FD2, -2.149) == FD2(-2.14)
+    @test floor_alt(FD2, -2.149) == FD2(-2.15)
+    @test ceil_alt(FD2,  -2.149) == FD2(-2.14)
+
+    @test trunc_alt(FD2, nextfloat(0.0)) == FD2(0)
+    @test floor_alt(FD2, nextfloat(0.0)) == FD2(0)
+    @test ceil_alt(FD2,  nextfloat(0.0)) == FD2(0.01)
+
+    @test trunc_alt(FD2, prevfloat(0.0)) == FD2(0)
+    @test floor_alt(FD2, prevfloat(0.0)) == FD2(-0.01)
+    @test ceil_alt(FD2,  prevfloat(0.0)) == FD2(0)
+end
+
 @testset "max_exp10" begin
     @test FixedPointDecimals.max_exp10(Int8) == 2
     @test FixedPointDecimals.max_exp10(Int64) == 18
@@ -629,18 +654,13 @@ end
         f = FixedPointDecimals.max_exp10(T)
         powt = FixedPointDecimals.coefficient(FD{T,f})
 
-        # Ideally we would just use `typemax(T)` but due to precision issues with
-        # floating-point its possible the closest float will exceed `typemax(T)`.
-        # Additionally, when the division results in a `BigFloat` we need to first
-        # truncate to a `BigInt` before we can truncate the type we want.
-        max_int = T(trunc(BigInt, prevfloat(typemax(T) / powt) * powt))
-        min_int = T(trunc(BigInt, nextfloat(typemin(T) / powt) * powt))
+        # When converting from typemax to a floating-point it is possible that due to
+        # precision issues that the closest possible float will exceed the typemax.
+        max_float = prevfloat(convert(AbstractFloat, typemax(FD{T,f})))
+        min_float = nextfloat(convert(AbstractFloat, typemin(FD{T,f})))
 
-        # floating-point inprecision makes it hard to know exactly that value to
-        # expect. Since we're primarily looking for issues relating to overflow this
-        # we can have the expected result be a little flexible.
-        @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]
+        @test trunc(FD{T,f}, max_float) == trunc_alt(FD{T,f}, max_float)
+        @test trunc(FD{T,f}, min_float) == trunc_alt(FD{T,f}, min_float)
 
         @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))
@@ -694,23 +714,16 @@ epsi{T}(::Type{T}) = eps(T)
         f = FixedPointDecimals.max_exp10(T)
         powt = FixedPointDecimals.coefficient(FD{T,f})
 
-        # Ideally we would just use `typemax(T)` but due to precision issues with
-        # floating-point its possible the closest float will exceed `typemax(T)`.
-        # Additionally, when the division results in a `BigFloat` we need to first
-        # truncate to a `BigInt` before we can truncate the type we want.
-        max_int = T(trunc(BigInt, prevfloat(typemax(T) / powt) * powt))
-        min_int = T(trunc(BigInt, nextfloat(typemin(T) / powt) * powt))
-
-        max_dec = max_int / powt
-        min_dec = min_int / powt
+        # When converting from typemax to a floating-point it is possible that due to
+        # precision issues that the closest possible float will exceed the typemax.
+        max_float = prevfloat(convert(AbstractFloat, typemax(FD{T,f})))
+        min_float = nextfloat(convert(AbstractFloat, typemin(FD{T,f})))
 
-        # Note: Using a larger signed type as the max/min values may be at the
-        # limits and overflow when adding or subtracting 1.
-        @test value(floor(FD{T,f}, max_dec)) in [max_int, max_int - 1]
-        @test value(floor(FD{T,f}, min_dec)) in [min_int, signed(widen(min_int)) - 1]
+        @test floor(FD{T,f}, max_float) == floor_alt(FD{T,f}, max_float)
+        @test floor(FD{T,f}, min_float) == floor_alt(FD{T,f}, min_float)
 
-        @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]
+        @test ceil(FD{T,f}, max_float) == ceil_alt(FD{T,f}, max_float)
+        @test ceil(FD{T,f}, min_float) == ceil_alt(FD{T,f}, min_float)
 
         # Note: rounding away from zero will result in an exception.
         max_int = typemax(T)

test/utils.jl

@@ -0,0 +1,58 @@
+# Format a floating-point number as a string with a specific precision. Similar to
+# `@sprintf("%.$(dp)f", val)`.
+
+if VERSION < v"0.6-"
+    function float_string(val::AbstractFloat, dp::Integer)
+        # On Julia 0.5 positive 0.0 can have extra bits. No other integer floating-point
+        # seems to have this problem.
+        isequal(val, 0.0) && return rpad("0.", dp, '0')
+        format = "%.$(dp)f"
+        @eval @sprintf($("%.$(dp)f"), nextfloat(0.0))
+        @eval begin
+            let buffer = Array{UInt8}(100 + $dp)
+                ccall((:snprintf, :libc), Int, (Ptr{UInt8}, Csize_t, Cstring, Cdouble), buffer, length(buffer), $format, $val)
+                unsafe_string(pointer(buffer))
+            end
+        end
+    end
+else
+    function float_string(val::AbstractFloat, dp::Integer)
+        buffer = Array{UInt8}(100 + dp)
+        ccall((:snprintf, :libc), Int, (Ptr{UInt8}, Csize_t, Cstring, Cdouble), buffer, length(buffer), "%.$(dp)f", val)
+        unsafe_string(pointer(buffer))
+    end
+end
+
+# FixedDecimal methods which perform an alternative method of trunc, floor, and ceil which
+# primarily use the string representation of the floating-point. These `*_alt` methods exist
+# to ensure the accuracy of the packages mathematical methods for trunc, floor, and ceil.
+
+function integer_alt{T<:Integer}(::Type{T}, dp::Integer, val::AbstractFloat)
+    # Note: Use a precision larger than the value can represent so that `sprintf` doesn't
+    # perform any rounding.
+    # TODO: Ideally we could be using just be using `@sprintf("%.325f", val)` once this
+    # issue is fixed: https://github.com/JuliaLang/julia/issues/22137
+    str = float_string(val, 325)  # 325 digits is large enough for `nextfloat(0.0)`
+    sign = T(first(str) == '-' ? -1 : 1)
+    decimal = findfirst(str, '.')
+    int_start = sign < 0 ? 2 : 1
+    int_end = decimal + dp
+    v = parse(T, str[int_start:(decimal - 1)] * str[(decimal + 1):int_end])
+    r = T(any(d -> d != '0', str[(int_end + 1):end]))  # Remaining digits
+    return (sign, v, r)
+end
+
+function trunc_alt{T<:Integer,f}(::Type{FD{T,f}}, val::AbstractFloat)
+    s, v, r = integer_alt(T, f, val)
+    reinterpret(FD{T,f}, copysign(v, s))
+end
+
+function floor_alt{T<:Integer,f}(::Type{FD{T,f}}, val::AbstractFloat)
+    s, v, r = integer_alt(T, f, val)
+    reinterpret(FD{T,f}, copysign(v + (s < 0 ? r : zero(T)), s))
+end
+
+function ceil_alt{T<:Integer,f}(::Type{FD{T,f}}, val::AbstractFloat)
+    s, v, r = integer_alt(T, f, val)
+    reinterpret(FD{T,f}, copysign(v + (s > 0 ? r : zero(T)), s))
+end