Merge pull request #59 from JuliaMath/teh/approx

Centralize floating-point conversion and implement isapprox

Author: timholy

src/FixedPointNumbers.jl

@@ -4,11 +4,11 @@ module FixedPointNumbers
 
 using Base: reducedim_initarray
 
-import Base: ==, <, <=, -, +, *, /, ~,
+import Base: ==, <, <=, -, +, *, /, ~, isapprox,
              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
 
@@ -51,10 +51,24 @@ reinterpret(x::FixedPoint) = x.i
 =={T <: FixedPoint}(x::T, y::T) = x.i == y.i
  <{T <: FixedPoint}(x::T, y::T) = x.i  < y.i
 <={T <: FixedPoint}(x::T, y::T) = x.i <= y.i
+"""
+    isapprox(x::FixedPoint, y::FixedPoint; rtol=0, atol=max(eps(x), eps(y)))
+
+For FixedPoint numbers, the default criterion is that `x` and `y` differ by no more than `eps`, the separation between adjacent fixed-point numbers.
+"""
+function isapprox{T<:FixedPoint}(x::T, y::T; rtol=0, atol=max(eps(x), eps(y)))
+    maxdiff = T(atol+rtol*max(abs(x), abs(y)))
+    rx, ry, rd = reinterpret(x), reinterpret(y), reinterpret(maxdiff)
+    abs(signed(widen1(rx))-signed(widen1(ry))) <= rd
+end
+function isapprox(x::FixedPoint, y::FixedPoint; rtol=0, atol=max(eps(x), eps(y)))
+    isapprox(promote(x, y)...; rtol=rtol, atol=atol)
+end
 
 # 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 +84,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
@@ -97,6 +126,17 @@ for T in tuple(Fixed16, UF...)
     end
 end
 
+for f in (:div, :fld, :fld1)
+    @eval begin
+        $f{T<:FixedPoint}(x::T, y::T) = $f(reinterpret(x),reinterpret(y))
+    end
+end
+for f in (:rem, :mod, :mod1, :rem1, :min, :max)
+    @eval begin
+        $f{T<:FixedPoint}(x::T, y::T) = T($f(reinterpret(x),reinterpret(y)),0)
+    end
+end
+
 # When multiplying by a float, reduce two multiplies to one.
 # Particularly useful for arrays.
 scaledual(Tdual::Type, x) = one(Tdual), x
@@ -115,7 +155,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)))
@@ -76,22 +80,8 @@ convert{Ti<:Integer}(::Type{Rational{Ti}}, x::UFixed) = convert(Ti, reinterpret(
 convert(::Type{Rational}, x::UFixed) = reinterpret(x)//rawone(x)
 
 # Traits
-eps{T<:UFixed}(::Type{T}) = T(one(rawtype(T)),0)
-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)
 
@@ -133,16 +123,6 @@ isinf(x::UFixed) = false
 bswap{f}(x::UFixed{UInt8,f}) = x
 bswap(x::UFixed)  = typeof(x)(bswap(reinterpret(x)),0)
 
-for f in (:div, :fld, :fld1)
-    @eval begin
-        $f{T<:UFixed}(x::T, y::T) = $f(reinterpret(x),reinterpret(y))
-    end
-end
-for f in (:rem, :mod, :mod1, :rem1, :min, :max)
-    @eval begin
-        $f{T<:UFixed}(x::T, y::T) = T($f(reinterpret(x),reinterpret(y)),0)
-    end
-end
 function minmax{T<:UFixed}(x::T, y::T)
     a, b = minmax(reinterpret(x), reinterpret(y))
     T(a,0), T(b,0)

test/fixed.jl

@@ -78,6 +78,10 @@ end
 @test ( 65.2 % T).i == round(Int,  65.2*512) % Int16
 @test (-67.2 % T).i == round(Int, -67.2*512) % Int16
 
+for T in [Fixed{Int8,7}, Fixed{Int16,8}, Fixed{Int16,10}]
+    testapprox(T)  # defined in ufixed.jl
+end
+
 # reductions
 F8 = Fixed{Int8,8}
 a = F8[0.498, 0.1]
@@ -97,6 +101,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
@@ -168,6 +172,18 @@ for T in (FixedPointNumbers.UF..., UF2...)
     testtrunc(eps(T))
 end
 
+function testapprox{T}(::Type{T})
+    for x = typemin(T):eps(T):typemax(T)-eps(T)
+        y = x+eps(T)
+        @test x ≈ y
+        @test y ≈ x
+        @test !(x ≈ y+eps(T))
+    end
+end
+for T in FixedPointNumbers.UF
+    testapprox(T)
+end
+
 @test !(UFixed8(0.5) < UFixed8(0.5))
 @test UFixed8(0.5) <= UFixed8(0.5)