Compact systematic display of values

Author: timholy

src/FixedPointNumbers.jl

@@ -26,27 +26,50 @@ using Compat
 # f => Number of Bytes reserved for fractional part
 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,
-    # literal constructor constants
+    U16,
+    # Q and U typealiases are exported in separate source files
+# literal constructor constants
     uf8,
     uf10,
     uf12,
     uf14,
     uf16,
-    # Functions
+# Functions
     scaledual
 
 reinterpret(x::FixedPoint) = x.i
 
+# construction using the (approximate) intended value, i.e., N0f8
+*{X<:FixedPoint}(x::Real, ::Type{X}) = X(x)
+
 # comparison
 =={T <: FixedPoint}(x::T, y::T) = x.i == y.i
  <{T <: FixedPoint}(x::T, y::T) = x.i  < y.i
@@ -90,6 +113,8 @@ floattype{T<:ShortInts,f}(::Type{FixedPoint{T,f}}) = Float32
 floattype{T,f}(::Type{FixedPoint{T,f}}) = Float64
 floattype(x::FixedPoint) = floattype(supertype(typeof(x)))
 
+# This IOBuffer is used during module definition to generate typealias names
+_iotypealias = IOBuffer()
 
 include("fixed.jl")
 include("ufixed.jl")
@@ -141,17 +166,6 @@ scaledual{T<:FixedPoint}(Tdual::Type, x::Union{T,AbstractArray{T}}) =
 scaledual{Tdual<:Number, T<:FixedPoint}(b::Tdual, x::Union{T,AbstractArray{T}}) =
     convert(Tdual, b/one(T)), reinterpret(rawtype(T), x)
 
-# printing
-function show{T,f}(io::IO, x::FixedPoint{T,f})
-    shorttype = typeof(x)<:UFixed ? "UFixed" : "Fixed"
-    print(io, shorttype, "{", T, ",", f, "}")
-    print(io, "(")
-    showcompact(io, x)
-    print(io, ")")
-end
-const _log2_10 = 3.321928094887362
-showcompact{T,f}(io::IO, x::FixedPoint{T,f}) = show(io, round(Float64(x), ceil(Int,f/_log2_10)))
-
 @noinline function throw_converterror{T<:FixedPoint}(::Type{T}, x)
     n = 2^(8*sizeof(T))
     bitstring = sizeof(T) == 1 ? "an 8-bit" : "a $(8*sizeof(T))-bit"

src/fixed.jl

@@ -9,13 +9,26 @@ immutable Fixed{T <: Signed,f} <: FixedPoint{T,  f}
     Fixed(x) = convert(Fixed{T,f}, x)
 end
 
-typealias Fixed16 Fixed{Int32, 16}
-
 reinterpret{T<:Signed, f}(::Type{Fixed{T,f}}, x::T) = Fixed{T,f}(x, 0)
 
   rawtype{T,f}(::Type{Fixed{T,f}}) = T
 nbitsfrac{T,f}(::Type{Fixed{T,f}}) = f
 floattype{T<:Fixed}(::Type{T}) = floattype(supertype(T))
+typechar{X<:Fixed}(::Type{X}) = 'Q'
+signbits{X<:Fixed}(::Type{X}) = 1
+
+for T in (Int8, Int16, Int32, Int64)
+    for f in 0:sizeof(T)*8-1
+        sym = Symbol(takebuf_string(showtype(_iotypealias, Fixed{T,f})))
+        @eval begin
+            typealias $sym Fixed{$T,$f}
+            export $sym
+        end
+    end
+end
+
+# ASCII typealiases
+typealias Fixed16 Fixed{Int32,16}
 
 # basic operators
 -{T,f}(x::Fixed{T,f}) = Fixed{T,f}(-x.i,0)

src/ufixed.jl

@@ -12,18 +12,34 @@ end
   rawtype(x::Number) = rawtype(typeof(x))
 nbitsfrac{T,f}(::Type{UFixed{T,f}}) = f
 floattype{T<:UFixed}(::Type{T}) = floattype(supertype(T))
+typechar{X<:UFixed}(::Type{X}) = 'N'
+signbits{X<:UFixed}(::Type{X}) = 0
+
+for T in (UInt8, UInt16, UInt32, UInt64)
+    for f in 0:sizeof(T)*8
+        sym = Symbol(takebuf_string(showtype(_iotypealias, UFixed{T,f})))
+        @eval begin
+            typealias $sym UFixed{$T,$f}
+            export $sym
+        end
+    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"
+## The next lines mimic the floating-point literal syntax "3.2f0"
+# construction using a UInt, i.e., 0xccuf8
 immutable UFixedConstructor{T,f} end
 *{T,f}(n::Integer, ::UFixedConstructor{T,f}) = UFixed{T,f}(n,0)
 const uf8  = UFixedConstructor{UInt8,8}()

test/fixed.jl

@@ -107,11 +107,11 @@ end
 @test isa(float(one(Fixed{Int32,25})), Float64)
 
 # Show
-x = Fixed{Int32,3}(0.25)
+x = Fixed{Int32,5}(0.25)
 iob = IOBuffer()
 show(iob, x)
 str = takebuf_string(iob)
-@test startswith(str, "Fixed{Int32,3}(")
+@test str == "0.25Q26f5"
 @test eval(parse(str)) == x
 
 for T in (Fixed{Int8,8}, Fixed{Int16,8}, Fixed{Int16,10}, Fixed{Int32,16})

test/ufixed.jl

@@ -13,6 +13,11 @@ using Compat
 @test reinterpret(UFixed12, 0x1fa2) == 0x1fa2uf12
 @test reinterpret(UFixed14, 0x1fa2) == 0x1fa2uf14
 @test reinterpret(UFixed16, 0x1fa2) == 0x1fa2uf16
+@test 0.635N0f8   == UFixed8(0.635)
+@test 0.635N6f10 == UFixed10(0.635)
+@test 0.635N4f12 == UFixed12(0.635)
+@test 0.635N2f14 == UFixed14(0.635)
+@test 0.635N0f16 == UFixed16(0.635)
 
 @test UFixed8(1.0) == 0xffuf8
 @test UFixed8(0.5) == 0x80uf8
@@ -234,7 +239,8 @@ x = 0xaauf8
 iob = IOBuffer()
 show(iob, x)
 str = takebuf_string(iob)
-@test str == "UFixed{UInt8,8}(0.667)"
+@test str == "0.667N0f8"
+@test eval(parse(str)) == x
 
 # scaledual
 function generic_scale!(C::AbstractArray, X::AbstractArray, s::Number)