Centralize conversion to floating point through floattype

Author: timholy

src/FixedPointNumbers.jl

@@ -8,7 +8,7 @@ import Base: ==, <, <=, -, +, *, /, ~,
              convert, promote_rule, show, showcompact, isinteger, abs, decompose,
              isnan, isinf, isfinite,
              zero, one, typemin, typemax, realmin, realmax, eps, sizeof, reinterpret,
-             trunc, round, floor, ceil, bswap,
+             float, trunc, round, floor, ceil, bswap,
              div, fld, rem, mod, mod1, rem1, fld1, min, max, minmax,
              start, next, done, r_promote, reducedim_init
 
@@ -55,6 +55,7 @@ reinterpret(x::FixedPoint) = x.i
 # predicates
 isinteger{T,f}(x::FixedPoint{T,f}) = (x.i&(1<<f-1)) == 0
 
+# traits
 typemax{T<: FixedPoint}(::Type{T}) = T(typemax(rawtype(T)), 0)
 typemin{T<: FixedPoint}(::Type{T}) = T(typemin(rawtype(T)), 0)
 realmin{T<: FixedPoint}(::Type{T}) = typemin(T)
@@ -70,10 +71,25 @@ widen1(::Type{Int64})  = Int128
 widen1(::Type{UInt64}) = UInt128
 widen1(x::Integer) = x % widen1(typeof(x))
 
+if VERSION <= v"0.5.0-dev+755"
+    @generated function floattype{T,f}(::Type{FixedPoint{T,f}})
+        f>22 ? :(Float64) : :(Float32)
+    end
+else
+    @pure function floattype{T,f}(::Type{FixedPoint{T,f}})
+        f>22 ? Float64 : Float32
+    end
+end
+floattype(x::FixedPoint) = floattype(supertype(typeof(x)))
+
+
 include("fixed.jl")
 include("ufixed.jl")
 include("deprecations.jl")
 
+eps{T<:FixedPoint}(::Type{T}) = T(one(rawtype(T)),0)
+eps{T<:FixedPoint}(::T) = eps(T)
+sizeof{T<:FixedPoint}(::Type{T}) = sizeof(rawtype(T))
 
 # Promotions for reductions
 const Treduce = Float64
@@ -115,7 +131,7 @@ function show{T,f}(io::IO, x::FixedPoint{T,f})
     print(io, ")")
 end
 const _log2_10 = 3.321928094887362
-showcompact{T,f}(io::IO, x::FixedPoint{T,f}) = show(io, round(convert(Float64,x), ceil(Int,f/_log2_10)))
+showcompact{T,f}(io::IO, x::FixedPoint{T,f}) = show(io, round(float(x), ceil(Int,f/_log2_10)))
 
 @noinline function throw_converterror{T<:FixedPoint}(::Type{T}, x)
     n = 2^(8*sizeof(T))

src/fixed.jl

@@ -13,6 +13,7 @@ typealias Fixed16 Fixed{Int32, 16}
 
   rawtype{T,f}(::Type{Fixed{T,f}}) = T
 nbitsfrac{T,f}(::Type{Fixed{T,f}}) = f
+floattype{T<:Fixed}(::Type{T}) = floattype(supertype(T))
 
 # basic operators
 -{T,f}(x::Fixed{T,f}) = Fixed{T,f}(-x.i,0)
@@ -37,6 +38,9 @@ convert{T,f}(::Type{Fixed{T,f}}, x::Rational) = Fixed{T,f}(x.num)/Fixed{T,f}(x.d
 rem{T,f}(x::Integer, ::Type{Fixed{T,f}}) = Fixed{T,f}(rem(x,T)<<f,0)
 rem{T,f}(x::Real,    ::Type{Fixed{T,f}}) = Fixed{T,f}(rem(Integer(trunc(x)),T)<<f + rem(Integer(round(rem(x,1)*(1<<f))),T),0)
 
+# convert{T,f}(::Type{AbstractFloat}, x::Fixed{T,f}) = convert(floattype(x), x)
+float(x::Fixed) = convert(floattype(x), x)
+
 convert{T,f}(::Type{BigFloat}, x::Fixed{T,f}) =
     convert(BigFloat,x.i>>f) + convert(BigFloat,x.i&(1<<f - 1))/convert(BigFloat,1<<f)
 convert{TF<:AbstractFloat,T,f}(::Type{TF}, x::Fixed{T,f}) =

src/ufixed.jl

@@ -11,6 +11,7 @@ end
   rawtype{T,f}(::Type{UFixed{T,f}}) = T
   rawtype(x::Number) = rawtype(typeof(x))
 nbitsfrac{T,f}(::Type{UFixed{T,f}}) = f
+floattype{T<:UFixed}(::Type{T}) = floattype(supertype(T))
 
 typealias UFixed8  UFixed{UInt8,8}
 typealias UFixed10 UFixed{UInt16,10}
@@ -65,6 +66,9 @@ rem{T<:UFixed}(x::T, ::Type{T}) = x
 rem{T<:UFixed}(x::UFixed, ::Type{T}) = reinterpret(T, _unsafe_trunc(rawtype(T), round((rawone(T)/rawone(x))*reinterpret(x))))
 rem{T<:UFixed}(x::Real, ::Type{T}) = reinterpret(T, _unsafe_trunc(rawtype(T), round(rawone(T)*x)))
 
+# convert(::Type{AbstractFloat}, x::UFixed) = convert(floattype(x), x)
+float(x::UFixed) = convert(floattype(x), x)
+
 convert(::Type{BigFloat}, x::UFixed) = reinterpret(x)*(1/BigFloat(rawone(x)))
 function convert{T<:AbstractFloat}(::Type{T}, x::UFixed)
     y = reinterpret(x)*(one(rawtype(x))/convert(T, rawone(x)))
@@ -81,17 +85,6 @@ eps{T<:UFixed}(::T) = eps(T)
 sizeof{T<:UFixed}(::Type{T}) = sizeof(rawtype(T))
 abs(x::UFixed) = x
 
-# Arithmetic
-if VERSION <= v"0.5.0-dev+755"
-    @generated function floattype{T,f}(::Type{UFixed{T,f}})
-        f>22 ? :(Float64) : :(Float32)
-    end
-else
-    @pure function floattype{T,f}(::Type{UFixed{T,f}})
-        f>22 ? Float64 : Float32
-    end
-end
-
 (-){T<:UFixed}(x::T) = T(-reinterpret(x), 0)
 (~){T<:UFixed}(x::T) = T(~reinterpret(x), 0)
 

test/fixed.jl

@@ -97,6 +97,11 @@ for T in (Float16, Float32, Float64, BigFloat)
     @test isa(y, T)
 end
 
+# Floating-point conversions
+@test isa(float(one(Fixed{Int8,6})),   Float32)
+@test isa(float(one(Fixed{Int32,18})), Float32)
+@test isa(float(one(Fixed{Int32,25})), Float64)
+
 # Show
 x = Fixed{Int32,3}(0.25)
 iob = IOBuffer()

test/ufixed.jl

@@ -111,11 +111,15 @@ x = UFixed8(0b01010001, 0)
 @test ~x == UFixed8(0b10101110, 0)
 @test -x == 0xafuf8
 
+@test isa(float(one(UFixed{UInt8,7})),   Float32)
+@test isa(float(one(UFixed{UInt32,18})), Float32)
+@test isa(float(one(UFixed{UInt32,25})), Float64)
+
 for T in (FixedPointNumbers.UF..., UF2...)
     x = T(0x10,0)
     y = T(0x25,0)
-    fx = convert(FixedPointNumbers.floattype(T), x)
-    fy = convert(FixedPointNumbers.floattype(T), y)
+    fx = float(x)
+    fy = float(y)
     @test y > x
     @test y != x
     @test typeof(x+y) == T