Compact systematic display of values

Author: timholy

src/FixedPointNumbers.jl

@@ -18,27 +18,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., 0.8U⁰₈
+*{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
@@ -62,11 +85,13 @@ widen1(::Type{Int64})  = Int128
 widen1(::Type{UInt64}) = UInt128
 widen1(x::Integer) = x % widen1(typeof(x))
 
+# This IOBuffer is used during module definition to generate typealias names
+_iotypealias = IOBuffer()
+
 include("fixed.jl")
 include("ufixed.jl")
 include("deprecations.jl")
 
-
 # Promotions for reductions
 const Treduce = Float64
 r_promote{T}(::typeof(@functorize(+)), x::FixedPoint{T}) = Treduce(x)
@@ -98,15 +123,4 @@ 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(convert(Float64,x), ceil(Int,f/_log2_10)))
-
 end # module

src/fixed.jl

@@ -9,10 +9,23 @@ immutable Fixed{T <: Signed,f} <: FixedPoint{T,  f}
     Fixed(x) = convert(Fixed{T,f}, x)
 end
 
-typealias Fixed16 Fixed{Int32, 16}
-
   rawtype{T,f}(::Type{Fixed{T,f}}) = T
 nbitsfrac{T,f}(::Type{Fixed{T,f}}) = f
+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

@@ -10,18 +10,34 @@ end
 
   rawtype{T,f}(::Type{UFixed{T,f}}) = T
 nbitsfrac{T,f}(::Type{UFixed{T,f}}) = f
+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

@@ -84,9 +84,9 @@ for T in (Float16, Float32, Float64, BigFloat)
 end
 
 # 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

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
@@ -159,7 +164,7 @@ x = 0xaauf8
 iob = IOBuffer()
 show(iob, x)
 str = takebuf_string(iob)
-@test startswith(str, "UFixed{UInt8,8}(")
+@test str == "0.667N0f8"
 @test eval(parse(str)) == x
 
 # scaledual