Use widening in conversions. Fixes #21, fixes #37.

Author: timholy

src/FixedPointNumbers.jl

@@ -52,6 +52,16 @@ typemin{T<: FixedPoint}(::Type{T}) = T(typemin(rawtype(T)), 0)
 realmin{T<: FixedPoint}(::Type{T}) = typemin(T)
 realmax{T<: FixedPoint}(::Type{T}) = typemax(T)
 
+widen1(::Type{Int8})   = Int16
+widen1(::Type{UInt8})  = UInt16
+widen1(::Type{Int16})  = Int32
+widen1(::Type{UInt16}) = UInt32
+widen1(::Type{Int32})  = Int64
+widen1(::Type{UInt32}) = UInt64
+widen1(::Type{Int64})  = Int128
+widen1(::Type{UInt64}) = UInt128
+widen1(x::Integer) = x % widen1(typeof(x))
+
 include("fixed.jl")
 include("ufixed.jl")
 include("deprecations.jl")

src/fixed.jl

@@ -30,8 +30,8 @@ abs{T,f}(x::Fixed{T,f}) = Fixed{T,f}(abs(x.i),0)
 
 
 # # conversions and promotions
-convert{T,f}(::Type{Fixed{T,f}}, x::Integer) = Fixed{T,f}(convert(T,x)<<f,0)
-convert{T,f}(::Type{Fixed{T,f}}, x::AbstractFloat) = Fixed{T,f}(trunc(T,x)<<f + round(T, rem(x,1)*(1<<f)),0)
+convert{T,f}(::Type{Fixed{T,f}}, x::Integer) = Fixed{T,f}(round(T, convert(widen1(T),x)<<f),0)
+convert{T,f}(::Type{Fixed{T,f}}, x::AbstractFloat) = Fixed{T,f}(round(T, trunc(widen1(T),x)<<f + rem(x,1)*(1<<f)),0)
 convert{T,f}(::Type{Fixed{T,f}}, x::Rational) = Fixed{T,f}(x.num)/Fixed{T,f}(x.den)
 
 convert{T,f}(::Type{BigFloat}, x::Fixed{T,f}) =

src/ufixed.jl

@@ -43,7 +43,9 @@ rawone(v) = reinterpret(one(v))
 convert{T<:UFixed}(::Type{T}, x::T) = x
 convert{T1<:UFixed}(::Type{T1}, x::UFixed) = reinterpret(T1, round(rawtype(T1), (rawone(T1)/rawone(x))*reinterpret(x)))
 convert(::Type{UFixed16}, x::UFixed8) = reinterpret(UFixed16, convert(UInt16, 0x0101*reinterpret(x)))
-convert{T<:UFixed}(::Type{T}, x::Real) = T(round(rawtype(T), rawone(T)*x),0)
+convert{U<:UFixed}(::Type{U}, x::Real) = _convert(U, rawtype(U), x)
+_convert{U<:UFixed,T}(::Type{U}, ::Type{T}, x)       = U(round(T, widen1(rawone(U))*x), 0)
+_convert{U<:UFixed  }(::Type{U}, ::Type{UInt128}, x) = U(round(UInt128, rawone(U)*x), 0)
 
 
 convert(::Type{BigFloat}, x::UFixed) = reinterpret(x)*(1/BigFloat(rawone(x)))

test/fixed.jl

@@ -50,6 +50,14 @@ function test_fixed{T}(::Type{T}, f)
     end
 end
 
+@test_approx_eq_eps convert(Fixed{Int8,7}, 0.8) 0.797 0.001
+@test_approx_eq_eps convert(Fixed{Int8,7}, 0.9) 0.898 0.001
+@test_throws InexactError convert(Fixed{Int8, 7}, 0.999)
+@test_throws InexactError convert(Fixed{Int8, 7}, 1.0)
+@test_throws InexactError convert(Fixed{Int8, 7}, 1)
+@test_throws InexactError convert(Fixed{Int8, 7}, 2)
+@test_throws InexactError convert(Fixed{Int8, 7}, 128)
+
 for (TI, f) in [(Int8, 8), (Int16, 8), (Int16, 10), (Int32, 16)]
     T = Fixed{TI,f}
     println("  Testing $T")

test/ufixed.jl

@@ -44,6 +44,15 @@ end
 @test typemax(UFixed{UInt64,3}) == typemax(UInt64) // (2^3-1)
 @test typemax(UFixed{UInt128,7}) == typemax(UInt128) // (2^7-1)
 
+@test_throws InexactError UFixed8(2)
+@test_throws InexactError UFixed8(255)
+@test_throws InexactError UFixed8(0xff)
+@test_throws InexactError UFixed16(2)
+@test_throws InexactError UFixed16(0xff)
+@test_throws InexactError UFixed16(0xffff)
+@test_throws InexactError convert(UFixed8,  typemax(UFixed10))
+@test_throws InexactError convert(UFixed16, typemax(UFixed10))
+
 x = UFixed8(0.5)
 @test isfinite(x) == true
 @test isnan(x) == false