Deprecate UFixed8 and friends in favor of N0f8 and friends

Author: timholy

src/FixedPointNumbers.jl

@@ -27,34 +27,11 @@ using Compat
 abstract FixedPoint{T <: Integer, f} <: Real
 
 
-# Printing. These are used to generate type-symbols, so we need them early.
-function showtype{X<:FixedPoint}(io::IO, ::Type{X})
-    print(io, typechar(X))
-    f = nbitsfrac(X)
-    m = sizeof(X)*8-f-signbits(X)
-    print(io, m, 'f', f)
-    io
-end
-function show{T,f}(io::IO, x::FixedPoint{T,f})
-    showcompact(io, x)
-    showtype(io, typeof(x))
-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)))
-
 export
     FixedPoint,
     Fixed,
     UFixed,
 # "special" typealiases
-    Fixed16,
-    UFixed8,
-    U8,
-    UFixed10,
-    UFixed12,
-    UFixed14,
-    UFixed16,
-    U16,
     # Q and U typealiases are exported in separate source files
 # literal constructor constants
     uf8,
@@ -66,6 +43,7 @@ export
     scaledual
 
 reinterpret(x::FixedPoint) = x.i
+reinterpret{T,f}(::Type{T}, x::FixedPoint{T,f}) = x.i
 
 # construction using the (approximate) intended value, i.e., N0f8
 *{X<:FixedPoint}(x::Real, ::Type{X}) = X(x)
@@ -116,6 +94,23 @@ floattype(x::FixedPoint) = floattype(supertype(typeof(x)))
 # This IOBuffer is used during module definition to generate typealias names
 _iotypealias = IOBuffer()
 
+# Printing. These are used to generate type-symbols, so we need them
+# before we include any files.
+function showtype{X<:FixedPoint}(io::IO, ::Type{X})
+    print(io, typechar(X))
+    f = nbitsfrac(X)
+    m = sizeof(X)*8-f-signbits(X)
+    print(io, m, 'f', f)
+    io
+end
+function show{T,f}(io::IO, x::FixedPoint{T,f})
+    showcompact(io, x)
+    showtype(io, typeof(x))
+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)))
+
+
 include("fixed.jl")
 include("ufixed.jl")
 include("deprecations.jl")
@@ -138,14 +133,6 @@ reducedim_init{T<:FixedPoint}(f::typeof(@functorize(identity)),
                               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.i
-    end
-end
-
 for f in (:div, :fld, :fld1)
     @eval begin
         $f{T<:FixedPoint}(x::T, y::T) = $f(reinterpret(x),reinterpret(y))

src/deprecations.jl

@@ -1,22 +1,32 @@
 import Base.@deprecate_binding
 
+@deprecate_binding Fixed16 Q15f16
+@deprecate_binding UFixed8 N0f8
+@deprecate_binding UFixed10 N6f10
+@deprecate_binding UFixed12 N4f12
+@deprecate_binding UFixed14 N2f14
+@deprecate_binding UFixed16 N0f16
+
 @deprecate_binding UfixedBase UFixed
 @deprecate_binding UfixedConstructor UFixedConstructor
 @deprecate_binding Ufixed UFixed
-@deprecate_binding Ufixed8 UFixed8
-@deprecate_binding Ufixed10 UFixed10
-@deprecate_binding Ufixed12 UFixed12
-@deprecate_binding Ufixed14 UFixed14
-@deprecate_binding Ufixed16 UFixed16
+@deprecate_binding Ufixed8 N0f8
+@deprecate_binding Ufixed10 N6f10
+@deprecate_binding Ufixed12 N4f12
+@deprecate_binding Ufixed14 N2f14
+@deprecate_binding Ufixed16 N0f16
+
+@deprecate_binding Fixed32 Q15f16
+
+const UF = (N0f8, N6f10, N4f12, N2f14, N0f16)
 
-@deprecate_binding Fixed32 Fixed16
 @deprecate Fixed(x::Real) convert(Fixed{Int32, 16}, x)
 
-@deprecate ufixed8(x)  UFixed8(x)
-@deprecate ufixed10(x) UFixed10(x)
-@deprecate ufixed12(x) UFixed12(x)
-@deprecate ufixed14(x) UFixed14(x)
-@deprecate ufixed16(x) UFixed16(x)
+@deprecate ufixed8(x)  N0f8(x)
+@deprecate ufixed10(x) N6f10(x)
+@deprecate ufixed12(x) N4f12(x)
+@deprecate ufixed14(x) N2f14(x)
+@deprecate ufixed16(x) N0f16(x)
 
 Compat.@dep_vectorize_1arg Real ufixed8
 Compat.@dep_vectorize_1arg Real ufixed10

src/fixed.jl

@@ -27,8 +27,7 @@ for T in (Int8, Int16, Int32, Int64)
     end
 end
 
-# ASCII typealiases
-typealias Fixed16 Fixed{Int32,16}
+reinterpret{T<:Signed, f}(::Type{Fixed{T,f}}, x::T) = Fixed{T,f}(x, 0)
 
 # basic operators
 -{T,f}(x::Fixed{T,f}) = Fixed{T,f}(-x.i,0)

src/ufixed.jl

@@ -1,5 +1,5 @@
 # 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
+# For example, UFixed{UInt8,8} == N0f8 maps 0x00 to 0.0 and 0xff to 1.0
 
 immutable UFixed{T<:Unsigned,f} <: FixedPoint{T,f}
     i::T
@@ -25,17 +25,6 @@ for T in (UInt8, UInt16, UInt32, UInt64)
     end
 end
 
-# ASCII typealiases
-typealias U8       UFixed{UInt8,8}
-typealias UFixed8  UFixed{UInt8,8}
-typealias UFixed10 UFixed{UInt16,10}
-typealias UFixed12 UFixed{UInt16,12}
-typealias UFixed14 UFixed{UInt16,14}
-typealias UFixed16 UFixed{UInt16,16}
-typealias U16      UFixed{UInt16,16}
-
-const UF = (UFixed8, UFixed10, UFixed12, UFixed14, UFixed16)
-
 reinterpret{T<:Unsigned, f}(::Type{UFixed{T,f}}, x::T) = UFixed{T,f}(x, 0)
 
 ## The next lines mimic the floating-point literal syntax "3.2f0"
@@ -65,7 +54,7 @@ function convert{T,T2,f}(::Type{UFixed{T,f}}, x::UFixed{T2})
     (0 <= y) & (y <= typemax(T)) || throw_converterror(U, x)
     reinterpret(U, _unsafe_trunc(T, y))
 end
-convert(::Type{UFixed16}, x::UFixed8) = reinterpret(UFixed16, convert(UInt16, 0x0101*reinterpret(x)))
+convert(::Type{N0f16}, x::N0f8) = reinterpret(N0f16, convert(UInt16, 0x0101*reinterpret(x)))
 convert{U<:UFixed}(::Type{U}, x::Real) = _convert(U, rawtype(U), x)
 function _convert{U<:UFixed,T}(::Type{U}, ::Type{T}, x)
     y = round(widen1(rawone(U))*x)