Fix issues with UInt128 and high-precision UFixed types

Author: timholy

src/ufixed.jl

@@ -9,7 +9,9 @@ immutable UFixed{T<:Unsigned,f} <: FixedPoint{T,f}
 end
 
   rawtype{T,f}(::Type{UFixed{T,f}}) = T
+  rawtype(x::Number) = rawtype(typeof(x))
 nbitsfrac{T,f}(::Type{UFixed{T,f}}) = f
+nbitsfrac(x::Number) = nbitsfract(typeof(x))
 
 typealias UFixed8  UFixed{UInt8,8}
 typealias UFixed10 UFixed{UInt16,10}
@@ -31,9 +33,8 @@ const uf14 = UFixedConstructor{UInt16,14}()
 const uf16 = UFixedConstructor{UInt16,16}()
 
 zero{T,f}(::Type{UFixed{T,f}}) = UFixed{T,f}(zero(T),0)
-@generated function one{T<:UFixed}(::Type{T})
-    f = 2^nbitsfrac(T)-1
-    :( T($f,0) )
+function one{T<:UFixed}(::Type{T})
+    T(typemax(rawtype(T)) >> (8*sizeof(T)-nbitsfrac(T)), 0)
 end
 zero(x::UFixed) = zero(typeof(x))
  one(x::UFixed) =  one(typeof(x))
@@ -65,7 +66,7 @@ rem{T<:UFixed}(x::Real, ::Type{T}) = reinterpret(T, _unsafe_trunc(rawtype(T), ro
 
 convert(::Type{BigFloat}, x::UFixed) = reinterpret(x)*(1/BigFloat(rawone(x)))
 function convert{T<:AbstractFloat}(::Type{T}, x::UFixed)
-    y = reinterpret(x)*(1/convert(T, rawone(x)))
+    y = reinterpret(x)*(one(rawtype(x))/convert(T, rawone(x)))
     convert(T, y)  # needed for types like Float16 which promote arithmetic to Float32
 end
 convert(::Type{Bool}, x::UFixed) = x == zero(x) ? false : true
@@ -80,13 +81,17 @@ sizeof{T<:UFixed}(::Type{T}) = sizeof(rawtype(T))
 abs(x::UFixed) = x
 
 # Arithmetic
+@generated function floattype{U<:UFixed}(::Type{U})
+    eps(U) < eps(Float32) ? :(Float64) : :(Float32)
+end
+
 (-){T<:UFixed}(x::T) = T(-reinterpret(x), 0)
 (~){T<:UFixed}(x::T) = T(~reinterpret(x), 0)
 
 +{T,f}(x::UFixed{T,f}, y::UFixed{T,f}) = UFixed{T,f}(convert(T, x.i+y.i),0)
 -{T,f}(x::UFixed{T,f}, y::UFixed{T,f}) = UFixed{T,f}(convert(T, x.i-y.i),0)
-*{T<:UFixed}(x::T, y::T) = convert(T,convert(Float32, x)*convert(Float32, y))
-/{T<:UFixed}(x::T, y::T) = convert(T,convert(Float32, x)/convert(Float32, y))
+*{T<:UFixed}(x::T, y::T) = convert(T,convert(floattype(T), x)*convert(floattype(T), y))
+/{T<:UFixed}(x::T, y::T) = convert(T,convert(floattype(T), x)/convert(floattype(T), y))
 
 # Comparisons
  <{T<:UFixed}(x::T, y::T) = reinterpret(x) < reinterpret(y)

test/ufixed.jl

@@ -21,7 +21,7 @@ v = @compat UFixed12.([2])
 @test v == UFixed12[0x1ffeuf12]
 @test isa(v, Vector{UFixed12})
 
-UF2 = (UFixed{UInt32,16}, UFixed{UInt64,3}, UFixed{UInt128,7})
+UF2 = (UFixed{UInt32,16}, UFixed{UInt64,3}, UFixed{UInt64,51}, UFixed{UInt128,7}, UFixed{UInt128,51})
 
 for T in (FixedPointNumbers.UF..., UF2...)
     @test zero(T) == 0
@@ -43,6 +43,7 @@ end
 @test typemax(UFixed{UInt32,16}) == typemax(UInt32) // (2^16-1)
 @test typemax(UFixed{UInt64,3}) == typemax(UInt64) // (2^3-1)
 @test typemax(UFixed{UInt128,7}) == typemax(UInt128) // (2^7-1)
+@test typemax(UFixed{UInt128,100}) == typemax(UInt128) // (UInt128(2)^100-1)
 
 # TODO: change back to InexactError when it allows message strings
 @test_throws ArgumentError UFixed8(2)
@@ -53,6 +54,8 @@ end
 @test_throws ArgumentError UFixed16(0xffff)
 @test_throws ArgumentError convert(UFixed8,  typemax(UFixed10))
 @test_throws ArgumentError convert(UFixed16, typemax(UFixed10))
+@test_throws ArgumentError convert(UFixed{UInt128,100}, 10^9)
+@test_throws ArgumentError convert(UFixed{UInt128,100}, 10.0^9)
 
 x = UFixed8(0.5)
 @test isfinite(x) == true
@@ -104,8 +107,8 @@ x = UFixed8(0b01010001, 0)
 for T in (FixedPointNumbers.UF..., UF2...)
     x = T(0x10,0)
     y = T(0x25,0)
-    fx = convert(Float32, x)
-    fy = convert(Float32, y)
+    fx = convert(FixedPointNumbers.floattype(T), x)
+    fy = convert(FixedPointNumbers.floattype(T), y)
     @test y > x
     @test y != x
     @test typeof(x+y) == T