Implement isapprox for FixedPoint

By default it asks whether two FixedPoints are within eps of each other. Handy in testing.

Author: timholy

src/FixedPointNumbers.jl

@@ -4,7 +4,7 @@ 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,
@@ -51,6 +51,19 @@ 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
@@ -113,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

src/ufixed.jl

@@ -80,9 +80,6 @@ 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
 
 (-){T<:UFixed}(x::T) = T(-reinterpret(x), 0)
@@ -126,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]

test/ufixed.jl

@@ -172,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)