Turn Fixed into a general FixedPoint implementation.

This expands the implementation in Fixed to handle more cases and be
generally more useful. In the future `UFixed` should be merged in and
the special behaviour required by ColorTypes implemented as a new type,
based on this implementation.

Author: vchuravy

src/FixedPointNumbers.jl

@@ -41,25 +41,59 @@ export
     scaledual
 
 getindex(x::FixedPoint) = x.i
+reinterpret{T,f}(::Type{T}, x::FixedPoint{T,f}) = x[]
+# reinterpret{T <: Integer,f}(::Type{FixedPoint{T,f}}, x::T) = FixedPoint{T,f}(x, 0)
+
 
 # comparison
 =={T <: FixedPoint}(x::T, y::T) = x[] == y[]
  <{T <: FixedPoint}(x::T, y::T) = x[]  < y[]
 <={T <: FixedPoint}(x::T, y::T) = x[] <= y[]
 
-# predicates
-isinteger{T,f}(x::FixedPoint{T,f}) = (x[]&(1<<f-1)) == 0
+#predicates
+isfinite(x::FixedPoint) = true
+isnan(x::FixedPoint) = false
+isinf(x::FixedPoint) = false
 
+#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)
 realmax{T<: FixedPoint}(::Type{T}) = typemax(T)
+eps{T<:FixedPoint}(::Type{T}) = T(one(rawtype(T)),0)
+eps{T<:FixedPoint}(::T) = eps(T)
+sizeof{T<:FixedPoint}(::Type{T}) = sizeof(rawtype(T))
+
+zero{T <: FixedPoint}(::Type{T}) = T(zero(rawtype(T)),0)
+zero{T <: FixedPoint}(x::T) = zero(T)
+ one{T <: FixedPoint}(x::T) =  one(T)
+
+# Basic operators & arithmetics
+(-){T<:FixedPoint}(x::T) = T(-x[], 0)
+(~){T<:FixedPoint}(x::T) = T(~x[], 0)
+abs{T<:FixedPoint}(x::T) = T(abs(x[]),0)
+
++{T<:FixedPoint}(x::T, y::T) = T(x[] + y[],0)
+-{T<:FixedPoint}(x::T, y::T) = T(x[] - y[],0)
+
+for f in (:div, :fld, :rem, :mod, :mod1, :rem1, :fld1, :min, :max)
+ @eval begin
+     $f{T<:FixedPoint}(x::T, y::T) = T($f(x[],y[]),0)
+ end
+end
+
+function minmax{T<:FixedPoint}(x::T, y::T)
+ a, b = minmax(x[], y[])
+ T(a,0), T(b,0)
+end
+
+bswap{T <: Union{UInt8, Int8}, f}(x::FixedPoint{T,f}) = x
+bswap{T <: FixedPoint}(x::T)  = T(bswap(x[]),0)
 
 include("fixed.jl")
 include("ufixed.jl")
 include("deprecations.jl")
 
-
 # Promotions for reductions
 const Treduce = Float64
 for F in (AddFun, MulFun)
@@ -73,13 +107,12 @@ reducedim_init{T<:FixedPoint}(f::IdFun, op::MulFun,
                               A::AbstractArray{T}, region) =
     reducedim_initarray(A, region, one(Treduce))
 
-# TODO: rewrite this by @generated
-for T in tuple(Fixed16, UF...)
-    R = rawtype(T)
-    @eval begin
-        reinterpret(::Type{$R}, x::$T) = x[]
-    end
-end
+# Iteration
+# The main subtlety here is that iterating over 0x00uf8:0xffuf8 will wrap around
+# unless we iterate using a wider type
+start{T<:FixedPoint}(r::StepRange{T}) = convert(typeof(r.start[] + r.step[]), r.start[])
+next{T<:FixedPoint}(r::StepRange{T}, i::Integer) = (T(i,0), i+r.step[])
+done{T<:FixedPoint}(r::StepRange{T}, i::Integer) = isempty(r) || (i > r.stop[])
 
 # When multiplying by a float, reduce two multiplies to one.
 # Particularly useful for arrays.

src/fixed.jl

@@ -1,9 +1,19 @@
-# 32-bit fixed point; parameter `f` is the number of fraction bits
-immutable Fixed{T <: Signed,f} <: FixedPoint{T,  f}
+###
+# Fixed implements a general purpose FixedPoint number.
+# The underlying storage type is given by the parameter `T`,
+# and the number of fractional bits is given by `f`
+# The dot is just before the fractional part so in order to represent one,
+# `f` needs to be atleast smaller by 1 in the unsigned case and smaller by two
+# in the signed case, then the number of bits in `T`.
+#
+# In a further iteration of the design `Fixed` should be renamed to `FixedPoint` and the aliase `typealias Fixed{T <: Signed, f} FixedPoint{T, f}` and `typealias UFixed{T <: Unsigned, f} FixedPoint{T, f}` introduced.
+###
+immutable Fixed{T,f} <: FixedPoint{T,  f}
     i::T
 
     # constructor for manipulating the representation;
     # selected by passing an extra dummy argument
+    Fixed(i::T, _) = new(i)
     Fixed(i::Integer,_) = new(i % T)
 
     Fixed(x) = convert(Fixed{T,f}, x)
@@ -14,22 +24,73 @@ typealias Fixed16 Fixed{Int32, 16}
   rawtype{T,f}(::Type{Fixed{T,f}}) = T
 nbitsfrac{T,f}(::Type{Fixed{T,f}}) = f
 
-# basic operators
--{T,f}(x::Fixed{T,f}) = Fixed{T,f}(-x[],0)
-abs{T,f}(x::Fixed{T,f}) = Fixed{T,f}(abs(x[]),0)
+reinterpret{T <: Integer,f}(::Type{Fixed{T,f}}, x::T) = Fixed{T,f}(x, 0)
 
-+{T,f}(x::Fixed{T,f}, y::Fixed{T,f}) = Fixed{T,f}(x[]+y[],0)
--{T,f}(x::Fixed{T,f}, y::Fixed{T,f}) = Fixed{T,f}(x[]-y[],0)
+## predicates
+isinteger{T,f}(x::Fixed{T,f}) = (x[]&(1<<f-1)) == 0
+
+function one{T, f}(::Type{Fixed{T, f}})
+    if T <: Unsigned && sizeof(T) * 8 > f ||
+       T <: Signed   && sizeof(T) * 8 > (f+1)
+        return Fixed{T, f}(2^f-1,0)
+    else
+        throw(DomainError())
+    end
+end
+
+## basic operators & arithmetics
 
 # with truncation:
-#*{f}(x::Fixed32{f}, y::Fixed32{f}) = Fixed32{f}(Base.widemul(x[],y[])>>f,0)
+# *{T<:Fixed}(x::T, y::T) =
+#         T(Base.widemul(x[],y[]) >> nbitsfrac(T),0)
 # with rounding up:
-*{T,f}(x::Fixed{T,f}, y::Fixed{T,f}) = Fixed{T,f}((Base.widemul(x[],y[]) + (convert(widen(T), 1) << (f-1) ))>>f,0)
+function *{T<:Fixed}(x::T, y::T)
+    f = nbitsfrac(T)
+    i = Base.widemul(x[],y[])
+    T((i + convert(widen(rawtype(T)), 1) << (f-1) )>>f,0)
+end
+
+function /{T<:Fixed}(x::T, y::T)
+    f = nbitsfrac(T)
+    T(div(convert(widen(rawtype(T)), x[]) << f, y.i), 0)
+end
+
+## rounding
+# Round towards negative infinity
+trunc{T<:Fixed}(x::T) = T(x[] & ~(1 << nbitsfrac(T) - 1), 0)
+# Round towards negative infinity
+floor{T<:Fixed}(x::T) = trunc(x)
+# Round towards positive infinity
+ceil{T<:Fixed}(x::T) = trunc(T(x[] + 1 << (nbitsfrac(T)-1), 0))
+# Round towards even
+function round{T<:Fixed}(x::T)
+    even = x[] & (1 << nbitsfrac(T)) == 0
+    if even
+        return floor(x)
+    else
+        return ceil(x)
+    end
+end
+# Round towards positive infinity
+ceil{T<:Fixed}(x::T) = trunc(T(x[] + 1 << (nbitsfrac(T)-1), 0))
+# Round towards even
+function round{T<:Fixed}(x::T)
+    even = x[] & (1 << nbitsfrac(T)) == 0
+    if even
+        return floor(x)
+    else
+        return ceil(x)
+    end
+end
 
-/{T,f}(x::Fixed{T,f}, y::Fixed{T,f}) = Fixed{T,f}(div(convert(widen(T), x[]) << f, y[]), 0)
+trunc{TI<:Integer, T <: Fixed}(::Type{TI}, x::T) =
+    convert(TI, x[] >> nbitsfrac(T))
+floor{T<:Integer}(::Type{T}, x::Fixed) = trunc(T, x)
+ceil{T<:Integer}(::Type{T}, x::Fixed) = trunc(T, ceil(x))
+round{T<:Integer}(::Type{T}, x::Fixed) = trunc(T, round(x))
 
 
-# # conversions and promotions
+## 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::Rational) = Fixed{T,f}(x.num)/Fixed{T,f}(x.den)
@@ -52,7 +113,6 @@ promote_rule{T,f,TI<:Integer}(ft::Type{Fixed{T,f}}, ::Type{TI}) = Fixed{T,f}
 promote_rule{T,f,TF<:AbstractFloat}(::Type{Fixed{T,f}}, ::Type{TF}) = TF
 promote_rule{T,f,TR}(::Type{Fixed{T,f}}, ::Type{Rational{TR}}) = Rational{TR}
 
-# TODO: Document and check that it still does the right thing.
 decompose{T,f}(x::Fixed{T,f}) = x[], -f, 1
 
 # printing

src/ufixed.jl

@@ -1,10 +1,13 @@
 # UFixed{T,f} maps UInts from 0 to 2^f-1 to the range [0.0, 1.0]
 # For example, a UFixed8 maps 0x00 to 0.0 and 0xff to 1.0
-
 immutable UFixed{T<:Unsigned,f} <: FixedPoint{T,f}
     i::T
 
-    UFixed(i::Integer,_) = new(i%T)   # for setting by raw representation
+    # constructor for manipulating the representation;
+    # selected by passing an extra dummy argument
+    UFixed(i::T, _) = new(i)
+    UFixed(i::Integer,_) = new(i % T)
+
     UFixed(x) = convert(UFixed{T,f}, x)
 end
 
@@ -34,7 +37,6 @@ const uf12 = UFixedConstructor{UInt16,12}()
 const uf14 = UFixedConstructor{UInt16,14}()
 const uf16 = UFixedConstructor{UInt16,16}()
 
-zero{T,f}(::Type{UFixed{T,f}}) = UFixed{T,f}(zero(T),0)
 for uf in UF
     TT = rawtype(uf)
     f = nbitsfrac(uf)
@@ -43,8 +45,6 @@ for uf in UF
         one(::Type{$T}) = $T($(2^f-1),0)
     end
 end
-zero(x::UFixed) = zero(typeof(x))
- one(x::UFixed) =  one(typeof(x))
 rawone(v) = one(v)[]
 
 # Conversions
@@ -80,18 +80,9 @@ sizeof{T<:UFixed}(::Type{T}) = sizeof(rawtype(T))
 abs(x::UFixed) = x
 
 # Arithmetic
-(-){T<:UFixed}(x::T) = T(-x[], 0)
-(~){T<:UFixed}(x::T) = T(~x[], 0)
-
-+{T,f}(x::UFixed{T,f}, y::UFixed{T,f}) = UFixed{T,f}(convert(T, x[]+y[]),0)
--{T,f}(x::UFixed{T,f}, y::UFixed{T,f}) = UFixed{T,f}(convert(T, x[]-y[]),0)
 *{T,f}(x::UFixed{T,f}, y::UFixed{T,f}) = UFixed{T,f}((Base.widemul(x[],y[]) + (convert(widen(T), 1) << (f-1) ))>>f,0)
 /{T,f}(x::UFixed{T,f}, y::UFixed{T,f}) = UFixed{T,f}(div(convert(widen(T), x[])<<f, y[]),0)
 
-# Comparisons
- <{T<:UFixed}(x::T, y::T) = x[] < y[]
-<={T<:UFixed}(x::T, y::T) = x[] < y[]
-
 # Functions
 trunc{T<:UFixed}(x::T) = T(div(x[], rawone(T))*rawone(T),0)
 floor{T<:UFixed}(x::T) = trunc(x)
@@ -116,36 +107,6 @@ round(x::UFixed) = round(Int, x)
 floor(x::UFixed) = floor(Int, x)
  ceil(x::UFixed) =  ceil(Int, x)
 
-isfinite(x::UFixed) = true
-isnan(x::UFixed) = false
-isinf(x::UFixed) = false
-
-bswap{f}(x::UFixed{UInt8,f}) = x
-bswap(x::UFixed)  = typeof(x)(bswap(x[]),0)
-
-for f in (:div, :fld, :rem, :mod, :mod1, :rem1, :fld1, :min, :max)
-    @eval begin
-        $f{T<:UFixed}(x::T, y::T) = T($f(x[],y[]),0)
-    end
-end
-function minmax{T<:UFixed}(x::T, y::T)
-    a, b = minmax(x[], y[])
-    T(a,0), T(b,0)
-end
-
-# Iteration
-# The main subtlety here is that iterating over 0x00uf8:0xffuf8 will wrap around
-# unless we iterate using a wider type
-if VERSION < v"0.3-"
-    start{T<:UFixed}(r::Range{T}) = convert(typeof(r.start[] + r.step[]), r.start[])
-    next{T<:UFixed}(r::Range{T}, i::Integer) = (T(i,0), i + r.step[])
-    done{T<:UFixed}(r::Range{T}, i::Integer) = isempty(r) || (i > r.len)
-else
-    start{T<:UFixed}(r::StepRange{T}) = convert(typeof(r.start[] + r.step[]), r.start[])
-    next{T<:UFixed}(r::StepRange{T}, i::Integer) = (T(i,0), i + r.step[])
-    done{T<:UFixed}(r::StepRange{T}, i::Integer) = isempty(r) || (i > r.stop[])
-end
-
 function decompose(x::UFixed)
     g = gcd(x[], rawone(x))
     div(x[],g), 0, div(rawone(x),g)