Replace reinterpret by getindex

Since writing `x.i` is so short compared to `reinterpret(x)`, it is
still all over the codebase. Using `getindex` gives a shorthand `x[]`
and makes the code cleaner to read. I was contemplating using `get`, but
there is no syntax sugar for that.

Author: vchuravy

src/FixedPointNumbers.jl

@@ -7,7 +7,7 @@ using Base: IdFun, AddFun, MulFun, reducedim_initarray
 import Base: ==, <, <=, -, +, *, /, ~,
              convert, promote_rule, show, showcompact, isinteger, abs, decompose,
              isnan, isinf, isfinite,
-             zero, one, typemin, typemax, realmin, realmax, eps, sizeof, reinterpret,
+             zero, one, typemin, typemax, realmin, realmax, eps, sizeof, reinterpret, getindex,
              trunc, round, floor, ceil, bswap,
              div, fld, rem, mod, mod1, rem1, fld1, min, max,
              start, next, done, r_promote, reducedim_init
@@ -40,15 +40,15 @@ export
     # Functions
     scaledual
 
-reinterpret(x::FixedPoint) = x.i
+getindex(x::FixedPoint) = x.i
 
 # comparison
-=={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
+=={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.i&(1<<f-1)) == 0
+isinteger{T,f}(x::FixedPoint{T,f}) = (x[]&(1<<f-1)) == 0
 
 typemax{T<: FixedPoint}(::Type{T}) = T(typemax(rawtype(T)), 0)
 typemin{T<: FixedPoint}(::Type{T}) = T(typemin(rawtype(T)), 0)
@@ -77,7 +77,7 @@ reducedim_init{T<:FixedPoint}(f::IdFun, op::MulFun,
 for T in tuple(Fixed16, UF...)
     R = rawtype(T)
     @eval begin
-        reinterpret(::Type{$R}, x::$T) = x.i
+        reinterpret(::Type{$R}, x::$T) = x[]
     end
 end
 

src/deprecations.jl

@@ -11,3 +11,4 @@ import Base.@deprecate_binding
 
 @deprecate_binding Fixed32 Fixed16
 @deprecate Fixed(x::Real) convert(Fixed{Int32, 16}, x)
+@deprecate reinterpret(x::FixedPoint) getindex(x)

src/fixed.jl

@@ -15,18 +15,18 @@ typealias Fixed16 Fixed{Int32, 16}
 nbitsfrac{T,f}(::Type{Fixed{T,f}}) = f
 
 # basic operators
--{T,f}(x::Fixed{T,f}) = Fixed{T,f}(-x.i,0)
-abs{T,f}(x::Fixed{T,f}) = Fixed{T,f}(abs(x.i),0)
+-{T,f}(x::Fixed{T,f}) = Fixed{T,f}(-x[],0)
+abs{T,f}(x::Fixed{T,f}) = Fixed{T,f}(abs(x[]),0)
 
-+{T,f}(x::Fixed{T,f}, y::Fixed{T,f}) = Fixed{T,f}(x.i+y.i,0)
--{T,f}(x::Fixed{T,f}, y::Fixed{T,f}) = Fixed{T,f}(x.i-y.i,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)
 
 # with truncation:
-#*{f}(x::Fixed32{f}, y::Fixed32{f}) = Fixed32{f}(Base.widemul(x.i,y.i)>>f,0)
+#*{f}(x::Fixed32{f}, y::Fixed32{f}) = Fixed32{f}(Base.widemul(x[],y[])>>f,0)
 # with rounding up:
-*{T,f}(x::Fixed{T,f}, y::Fixed{T,f}) = Fixed{T,f}((Base.widemul(x.i,y.i) + (convert(widen(T), 1) << (f-1) ))>>f,0)
+*{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)
 
-/{T,f}(x::Fixed{T,f}, y::Fixed{T,f}) = Fixed{T,f}(div(convert(widen(T), x.i) << f, y.i), 0)
+/{T,f}(x::Fixed{T,f}, y::Fixed{T,f}) = Fixed{T,f}(div(convert(widen(T), x[]) << f, y[]), 0)
 
 
 # # conversions and promotions
@@ -35,25 +35,25 @@ convert{T,f}(::Type{Fixed{T,f}}, x::AbstractFloat) = Fixed{T,f}(trunc(T,x)<<f +
 convert{T,f}(::Type{Fixed{T,f}}, x::Rational) = Fixed{T,f}(x.num)/Fixed{T,f}(x.den)
 
 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(BigFloat,x[]>>f) + convert(BigFloat,x[]&(1<<f - 1))/convert(BigFloat,1<<f)
 convert{TF<:AbstractFloat,T,f}(::Type{TF}, x::Fixed{T,f}) =
-    convert(TF,x.i>>f) + convert(TF,x.i&(1<<f - 1))/convert(TF,1<<f)
+    convert(TF,x[]>>f) + convert(TF,x[]&(1<<f - 1))/convert(TF,1<<f)
 
-convert{T,f}(::Type{Bool}, x::Fixed{T,f}) = x.i!=0
+convert{T,f}(::Type{Bool}, x::Fixed{T,f}) = x[]!=0
 function convert{TI<:Integer, T,f}(::Type{TI}, x::Fixed{T,f})
     isinteger(x) || throw(InexactError())
-    convert(TI, x.i>>f)
+    convert(TI, x[]>>f)
 end
 
 convert{TR<:Rational,T,f}(::Type{TR}, x::Fixed{T,f}) =
-    convert(TR, x.i>>f + (x.i&(1<<f-1))//(1<<f))
+    convert(TR, x[]>>f + (x[]&(1<<f-1))//(1<<f))
 
 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.i, -f, 1
+decompose{T,f}(x::Fixed{T,f}) = x[], -f, 1
 
 # printing
 function show(io::IO, x::Fixed)

src/ufixed.jl

@@ -45,12 +45,12 @@ for uf in UF
 end
 zero(x::UFixed) = zero(typeof(x))
  one(x::UFixed) =  one(typeof(x))
-rawone(v) = reinterpret(one(v))
+rawone(v) = one(v)[]
 
 # Conversions
 convert{T<:UFixed}(::Type{T}, x::T) = x
-convert{T1<:UFixed}(::Type{T1}, x::UFixed) = reinterpret(T1, round(rawtype(T1), (rawone(T1)/rawone(x))*reinterpret(x)))
-convert(::Type{UFixed16}, x::UFixed8) = reinterpret(UFixed16, convert(UInt16, 0x0101*reinterpret(x)))
+convert{T1<:UFixed}(::Type{T1}, x::UFixed) = reinterpret(T1, round(rawtype(T1), (rawone(T1)/rawone(x))*x[]))
+convert(::Type{UFixed16}, x::UFixed8) = reinterpret(UFixed16, convert(UInt16, 0x0101*x[]))
 convert{T<:UFixed}(::Type{T}, x::Real) = T(round(rawtype(T), rawone(T)*x),0)
 
 ufixed8(x)  = convert(UFixed8, x)
@@ -66,12 +66,12 @@ ufixed16(x) = convert(UFixed16, x)
 @vectorize_1arg Real ufixed16
 
 
-convert(::Type{BigFloat}, x::UFixed) = reinterpret(x)*(1/BigFloat(rawone(x)))
-convert{T<:AbstractFloat}(::Type{T}, x::UFixed) = reinterpret(x)*(1/convert(T, rawone(x)))
+convert(::Type{BigFloat}, x::UFixed) = x[]*(1/BigFloat(rawone(x)))
+convert{T<:AbstractFloat}(::Type{T}, x::UFixed) = x[]*(1/convert(T, rawone(x)))
 convert(::Type{Bool}, x::UFixed) = x == zero(x) ? false : true
 convert{T<:Integer}(::Type{T}, x::UFixed) = convert(T, x*(1/one(T)))
-convert{Ti<:Integer}(::Type{Rational{Ti}}, x::UFixed) = convert(Ti, reinterpret(x))//convert(Ti, rawone(x))
-convert(::Type{Rational}, x::UFixed) = reinterpret(x)//rawone(x)
+convert{Ti<:Integer}(::Type{Rational{Ti}}, x::UFixed) = convert(Ti, x[])//convert(Ti, rawone(x))
+convert(::Type{Rational}, x::UFixed) = x[]//rawone(x)
 
 # Traits
 eps{T<:UFixed}(::Type{T}) = T(one(rawtype(T)),0)
@@ -80,20 +80,20 @@ sizeof{T<:UFixed}(::Type{T}) = sizeof(rawtype(T))
 abs(x::UFixed) = x
 
 # Arithmetic
-(-){T<:UFixed}(x::T) = T(-reinterpret(x), 0)
-(~){T<:UFixed}(x::T) = T(~reinterpret(x), 0)
+(-){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.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,f}(x::UFixed{T,f}, y::UFixed{T,f}) = UFixed{T,f}((Base.widemul(x.i,y.i) + (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.i)<<f, y.i),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) = reinterpret(x) < reinterpret(y)
-<={T<:UFixed}(x::T, y::T) = reinterpret(x) < reinterpret(y)
+ <{T<:UFixed}(x::T, y::T) = x[] < y[]
+<={T<:UFixed}(x::T, y::T) = x[] < y[]
 
 # Functions
-trunc{T<:UFixed}(x::T) = T(div(reinterpret(x), rawone(T))*rawone(T),0)
+trunc{T<:UFixed}(x::T) = T(div(x[], rawone(T))*rawone(T),0)
 floor{T<:UFixed}(x::T) = trunc(x)
 for T in UF
     f = nbitsfrac(T)
@@ -102,15 +102,15 @@ for T in UF
     k = 8*sizeof(R)-f
     ceilmask  = (typemax(R)<<k)>>k
     @eval begin
-        round(x::$T) = (y = trunc(x); return convert(rawtype($T), reinterpret(x)-reinterpret(y))&$roundmask>0 ? $T(y+one($T)) : y)
-         ceil(x::$T) = (y = trunc(x); return convert(rawtype($T), reinterpret(x)-reinterpret(y))&$ceilmask >0 ? $T(y+one($T)) : y)
+        round(x::$T) = (y = trunc(x); return convert(rawtype($T), x[]-y[])&$roundmask>0 ? $T(y+one($T)) : y)
+         ceil(x::$T) = (y = trunc(x); return convert(rawtype($T), x[]-y[])&$ceilmask >0 ? $T(y+one($T)) : y)
     end
 end
 
-trunc{T<:Integer}(::Type{T}, x::UFixed) = convert(T, div(reinterpret(x), rawone(x)))
-round{T<:Integer}(::Type{T}, x::UFixed) = round(T, reinterpret(x)/rawone(x))
+trunc{T<:Integer}(::Type{T}, x::UFixed) = convert(T, div(x[], rawone(x)))
+round{T<:Integer}(::Type{T}, x::UFixed) = round(T, x[]/rawone(x))
 floor{T<:Integer}(::Type{T}, x::UFixed) = trunc(T, x)
- ceil{T<:Integer}(::Type{T}, x::UFixed) =  ceil(T, reinterpret(x)/rawone(x))
+ ceil{T<:Integer}(::Type{T}, x::UFixed) =  ceil(T, x[]/rawone(x))
 trunc(x::UFixed) = trunc(Int, x)
 round(x::UFixed) = round(Int, x)
 floor(x::UFixed) = floor(Int, x)
@@ -121,34 +121,34 @@ isnan(x::UFixed) = false
 isinf(x::UFixed) = false
 
 bswap{f}(x::UFixed{UInt8,f}) = x
-bswap(x::UFixed)  = typeof(x)(bswap(reinterpret(x)),0)
+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(reinterpret(x),reinterpret(y)),0)
+        $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(reinterpret(x), reinterpret(y))
+    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(reinterpret(r.start)+reinterpret(r.step)), reinterpret(r.start))
-    next{T<:UFixed}(r::Range{T}, i::Integer) = (T(i,0), i+reinterpret(r.step))
+    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(reinterpret(r.start)+reinterpret(r.step)), reinterpret(r.start))
-    next{T<:UFixed}(r::StepRange{T}, i::Integer) = (T(i,0), i+reinterpret(r.step))
-    done{T<:UFixed}(r::StepRange{T}, i::Integer) = isempty(r) || (i > reinterpret(r.stop))
+    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(reinterpret(x), rawone(x))
-    div(reinterpret(x),g), 0, div(rawone(x),g)
+    g = gcd(x[], rawone(x))
+    div(x[],g), 0, div(rawone(x),g)
 end
 
 # Promotions

test/ufixed.jl

@@ -1,10 +1,10 @@
 using FixedPointNumbers, Base.Test
 
-@test reinterpret(0xa2uf8)  == 0xa2
-@test reinterpret(0xa2uf10) == 0xa2
-@test reinterpret(0xa2uf12) == 0xa2
-@test reinterpret(0xa2uf14) == 0xa2
-@test reinterpret(0xa2uf16) == 0xa2
+@test (0xa2uf8)[] == 0xa2
+@test (0xa2uf10)[] == 0xa2
+@test (0xa2uf12)[] == 0xa2
+@test (0xa2uf14)[] == 0xa2
+@test (0xa2uf16)[] == 0xa2
 
 @test reinterpret(UFixed8, 0xa2) == 0xa2uf8
 @test reinterpret(UFixed10, 0x1fa2) == 0x1fa2uf10
@@ -90,9 +90,9 @@ end
 
 function testtrunc{T}(inc::T)
     incf = convert(Float64, inc)
-    tm = reinterpret(typemax(T))/reinterpret(one(T))
+    tm = typemax(T)[] / one(T)[]
     x = zero(T)
-    for i = 0:reinterpret(typemax(T))-1
+    for i = 0:typemax(T)[]-1
         xf = incf*i
         try
             @test trunc(x) == trunc(xf)