Improve consistency in printing

Author: kimikage

src/FixedPointNumbers.jl

@@ -216,27 +216,49 @@ function length(r::StepRange{<:FixedPoint})
     return div((stop - start) + step, step)
 end
 
+hasalias(::Type) = false
+hasalias(::Type{X}) where {T<:NotBiggerThanInt64, f, X<:FixedPoint{T,f}} = nbitsfrac(X) isa Int
+
 # Printing. These are used to generate type-symbols, so we need them
 # before we include any files.
-function showtype(io::IO, ::Type{X}) where {X <: FixedPoint}
-    print(io, typechar(X))
-    f = nbitsfrac(X)
-    m = bitwidth(X)-f-signbits(X)
-    print(io, m, 'f', f)
+@inline function showtype(io::IO, ::Type{X}) where {X <: FixedPoint}
+    if hasalias(X)
+        f = nbitsfrac(X)
+        m = bitwidth(X) - f - signbits(X)
+        write(io, typechar(X))
+        m > 9 && write(io, Char(m ÷ 10 + 0x30))
+        write(io, Char(m % 10 + 0x30), 'f')
+        f > 9 && write(io, Char(f ÷ 10 + 0x30))
+        write(io, Char(f % 10 + 0x30))
+    else
+        print(io, X)
+    end
     io
 end
+
 function show(io::IO, x::FixedPoint{T,f}) where {T,f}
+    compact = get(io, :compact, false)
     log10_2 = 0.3010299956639812
-    show(io, round(convert(Float64,x), digits=ceil(Int, f * log10_2)))
-    get(io, :compact, false) || showtype(io, typeof(x))
+    digits = min(ceil(Int, f * log10_2), compact ? 6 : typemax(Int))
+    val = round(convert(Float64, x), digits=digits)
+    if compact || get(io, :typeinfo, nothing) === typeof(x)
+        show(io, val)
+    elseif hasalias(typeof(x))
+        show(io, val)
+        showtype(io, typeof(x))
+    else
+        print(io, typeof(x), '(', val, ')')
+    end
 end
 
-function Base.showarg(io::IO, a::Array{T}, toplevel) where {T<:FixedPoint}
-    toplevel || print(io, "::")
-    print(io, "Array{")
-    showtype(io, T)
-    print(io, ",$(ndims(a))}")
-    toplevel && print(io, " with eltype ", T)
+if VERSION < v"1.6.0-DEV.356"
+    function Base.showarg(io::IO, a::Array{X}, toplevel) where {X<:FixedPoint}
+        toplevel || print(io, "::")
+        print(io, "Array{")
+        showtype(io, X)
+        print(io, ",$(ndims(a))}")
+        toplevel && hasalias(X) && print(io, " with eltype ", X)
+    end
 end
 
 include("fixed.jl")

src/fixed.jl

@@ -24,6 +24,9 @@ struct Fixed{T <: Signed, f} <: FixedPoint{T, f}
     end
 end
 
+# TODO: remove this
+hasalias(::Type{F}) where {F <: Union{Fixed{Int8,8},Fixed{Int16,16},Fixed{Int32,32},Fixed{Int64,64}}} = false
+
 typechar(::Type{X}) where {X <: Fixed} = 'Q'
 signbits(::Type{X}) where {X <: Fixed} = 1
 

src/utilities.jl

@@ -18,6 +18,7 @@ const LongInts = Union{Int64, UInt64, Int128, UInt128, BigInt}
 
 const ShorterThanInt = Int === Int32 ? ShortInts : Union{ShortInts, Int32, UInt32}
 const NotBiggerThanInt = Union{ShorterThanInt, Int, UInt}
+const NotBiggerThanInt64 = Union{ShortInts, Int32, UInt32, Int64, UInt64}
 const SShorterThanInt = typeintersect(ShorterThanInt, Signed)
 const UShorterThanInt = typeintersect(ShorterThanInt, Unsigned)
 

test/fixed.jl

@@ -358,15 +358,6 @@ end
     end
 end
 
-@testset "Show" begin
-    x = Fixed{Int32,5}(0.25)
-    iob = IOBuffer()
-    show(iob, x)
-    str = String(take!(iob))
-    @test str == "0.25Q26f5"
-    @test eval(Meta.parse(str)) == x
-end
-
 @testset "rand" begin
     for F in (Fixed{Int8,7}, Fixed{Int16,8}, Fixed{Int16,10}, Fixed{Int32,16})
         @test isa(rand(F), F)
@@ -433,3 +424,51 @@ end
     @test promote_type(Float32,Q0f7,Int) == Float32
     @test promote_type(Q0f7,Q1f6,Q2f5,Q3f4,Q4f3,Q5f2) == Fixed{Int128,7}
 end
+
+@testset "show" begin
+    iob = IOBuffer()
+    q0f7 = reinterpret(Q0f7, signed(0xaa))
+    show(iob, q0f7)
+    str = String(take!(iob))
+    @test str == "-0.672Q0f7"
+    @test eval(Meta.parse(str)) === q0f7
+
+    q15f16 = reinterpret(Q15f16, signed(0xaaaaaaaa))
+    show(iob, q15f16)
+    str = String(take!(iob))
+    @test str == "-21845.33334Q15f16"
+    @test eval(Meta.parse(str)) === q15f16
+
+    show(IOContext(iob, :compact=>true), q15f16)
+    @test String(take!(iob)) == "-21845.3"
+
+    show(IOContext(iob, :compact=>true, :typeinfo=>Q15f16), q15f16)
+    @test String(take!(iob)) == "-21845.3"
+
+    show(IOContext(iob, :compact=>true, :typeinfo=>Fixed), q15f16)
+    @test String(take!(iob)) == "-21845.3"
+
+    show(IOContext(iob, :typeinfo=>Q15f16), q15f16)
+    @test String(take!(iob)) == "-21845.33334"
+
+    show(IOContext(iob, :typeinfo=>Normed), q15f16)
+    @test String(take!(iob)) == "-21845.33334Q15f16"
+
+    show(iob, Fixed{Int128,64}(-1.2345e6))
+    @test String(take!(iob)) == "Fixed{Int128,64}(-1.2345e6)"
+
+    # TODO: remove this test
+    show(iob, reinterpret(Fixed{Int8,8}, signed(0xaa)))
+    @test String(take!(iob)) == "Fixed{Int8,8}(-0.336)"
+end
+
+@testset "summary" begin
+    a = Q0f7[0.2, 0.4]
+    if VERSION >= v"1.6.0-DEV.356"
+        @test summary(a) == "2-element Vector{Q0f7}"
+        @test summary(view(a, 1:2)) == "2-element view(::Vector{Q0f7}, 1:2) with eltype Q0f7"
+    else
+        @test summary(a) == "2-element Array{Q0f7,1} with eltype Fixed{Int8,7}"
+        @test summary(view(a, 1:2)) == "2-element view(::Array{Q0f7,1}, 1:2) with eltype Fixed{Int8,7}"
+    end
+end

test/normed.jl

@@ -403,12 +403,47 @@ end
 end
 
 @testset "show" begin
-    x = reinterpret(N0f8, 0xaa)
     iob = IOBuffer()
-    show(iob, x)
+    n0f8 = reinterpret(N0f8, 0xaa)
+    show(iob, n0f8)
     str = String(take!(iob))
     @test str == "0.667N0f8"
-    @test eval(Meta.parse(str)) == x
+    @test eval(Meta.parse(str)) === n0f8
+
+    n16f16 = reinterpret(N16f16, 0xaaaaaaaa)
+    show(iob, n16f16)
+    str = String(take!(iob))
+    @test str == "43691.33333N16f16"
+    @test eval(Meta.parse(str)) === n16f16
+
+    show(IOContext(iob, :compact=>true), n16f16)
+    @test String(take!(iob)) == "43691.3"
+
+    show(IOContext(iob, :compact=>true, :typeinfo=>N16f16), n16f16)
+    @test String(take!(iob)) == "43691.3"
+
+    show(IOContext(iob, :compact=>true, :typeinfo=>Normed), n16f16)
+    @test String(take!(iob)) == "43691.3"
+
+    show(IOContext(iob, :typeinfo=>N16f16), n16f16)
+    @test String(take!(iob)) == "43691.33333"
+
+    show(IOContext(iob, :typeinfo=>Normed), n16f16)
+    @test String(take!(iob)) == "43691.33333N16f16"
+
+    show(iob, Normed{UInt128,64}(1.2345e6))
+    @test String(take!(iob)) == "Normed{UInt128,64}(1.2345e6)"
+end
+
+@testset "summary" begin
+    a = N0f8[0.2, 0.4]
+    if VERSION >= v"1.6.0-DEV.356"
+        @test summary(a) == "2-element Vector{N0f8}"
+        @test summary(view(a, 1:2)) == "2-element view(::Vector{N0f8}, 1:2) with eltype N0f8"
+    else
+        @test summary(a) == "2-element Array{N0f8,1} with eltype Normed{UInt8,8}"
+        @test summary(view(a, 1:2)) == "2-element view(::Array{N0f8,1}, 1:2) with eltype Normed{UInt8,8}"
+    end
 end
 
 @testset "scaledual" begin
@@ -478,12 +513,6 @@ end
     @test Float16(1.0) % N0f16 === N0f16(1.0)
 end
 
-@testset "summary" begin
-    a = N0f8[0.2, 0.4]
-    @test summary(a) == "2-element Array{N0f8,1} with eltype Normed{UInt8,8}"
-    @test summary(view(a, 1:2)) == "2-element view(::Array{N0f8,1}, 1:2) with eltype Normed{UInt8,8}"
-end
-
 @testset "disambiguation constructors" begin
     @test_throws ArgumentError Normed{UInt32,16}('a')
     @test_throws InexactError  Normed{UInt32,16}(complex(1.0, 1.0))