Allow for Complex and Rationals and user types

Author: hhaensel

src/fmt.jl

@@ -29,7 +29,7 @@ function DefaultSpec(c::AbstractChar, syms...; kwargs...)
     end
 end
 
-const DEFAULT_FORMATTERS = Dict{DataType, DefaultSpec}()
+const DEFAULT_FORMATTERS = Dict{Type{T} where T, DefaultSpec}()
 
 # adds a new default formatter for this type
 default_spec!(::Type{T}, c::AbstractChar) where {T} =
@@ -79,6 +79,9 @@ default_spec(::Type{<:AbstractString}) = DEFAULT_FORMATTERS[AbstractString]
 default_spec(::Type{<:AbstractChar})   = DEFAULT_FORMATTERS[AbstractChar]
 default_spec(::Type{<:AbstractIrrational}) = DEFAULT_FORMATTERS[AbstractIrrational]
 default_spec(::Type{<:Number})         = DEFAULT_FORMATTERS[Number]
+default_spec(::Complex{T} where T<:Integer)       = DEFAULT_FORMATTERS[Complex{T} where T<:Integer]
+default_spec(::Complex{T} where T<:AbstractFloat) = DEFAULT_FORMATTERS[Complex{T} where T<:AbstractFloat]
+default_spec(::Complex{T} where T<:Rational)      = DEFAULT_FORMATTERS[Complex{T} where T<:Rational]
 
 default_spec(::Type{T}) where {T} =
     get(DEFAULT_FORMATTERS, T) do
@@ -189,7 +192,7 @@ function fmt end
 # TODO: do more caching to optimize repeated calls
 
 # creates a new FormatSpec by overriding the defaults and passes it to pyfmt
-# note: adding kwargs is only appropriate for one-off formatting.  
+# note: adding kwargs is only appropriate for one-off formatting.
 #       normally it will be much faster to change the fmt_default formatting as needed
 function fmt(x; kwargs...)
     fspec = fmt_default(x)
@@ -220,9 +223,12 @@ end
 for (t, c) in [(Integer,'d'),
                (AbstractFloat,'f'),
                (AbstractChar,'c'),
-               (AbstractString,'s')]
+               (AbstractString,'s'),
+               (Complex{T} where T<:Integer, 'd' ),
+               (Complex{T} where T<:AbstractFloat, 'f' )]
     default_spec!(t, c)
 end
 
 default_spec!(Number, 's', :right)
 default_spec!(AbstractIrrational, 's', :right)
+default_spec!(Complex{T} where T<:Rational, 's', :right)

src/fmtcore.jl

@@ -1,4 +1,5 @@
 # core formatting functions
+export fmt_Number
 
 ### auxiliary functions
 
@@ -262,3 +263,40 @@ function _pfmt_specialf(out::IO, fs::FormatSpec, x::AbstractFloat)
     end
 end
 
+function _pfmt_Number_f(out::IO, fs::FormatSpec, x::Number, _pf::Function)
+    fsi = FormatSpec(fs, width = -1)
+    f = x::AbstractFloat->begin
+        io = IOBuffer()
+        _pf(io, fsi, x)
+        String(take!(io))
+    end
+    s = fmt_Number(x, f)
+    _pfmt_s(out, fs, s)
+end
+
+function _pfmt_Number_i(out::IO, fs::FormatSpec, x::Number, op::Op, _pf::Function) where {Op}
+    fsi = FormatSpec(fs, width = -1)
+    f = x::Integer->begin
+        io = IOBuffer()
+        _pf(io, fsi, x, op)
+        String(take!(io))
+    end
+    s = fmt_Number(x, f)
+    _pfmt_s(out, fs, s)
+end
+
+function _pfmt_i(out::IO, fs::FormatSpec, x::Number, op::Op) where {Op}
+    _pfmt_Number_i(out, fs, x, op, _pfmt_i)
+end
+
+function _pfmt_f(out::IO, fs::FormatSpec, x::Number)
+    _pfmt_Number_f(out, fs, x, _pfmt_f)
+end
+
+function _pfmt_e(out::IO, fs::FormatSpec, x::Number)
+    _pfmt_Number_f(out, fs, x, _pfmt_e)
+end
+
+function fmt_Number(x::Complex, f::Function)
+    s = f(real(x)) * (imag(x) >= 0 ? " + " : " - ") * f(abs(imag(x))) * "im"
+end

src/fmtspec.jl

@@ -164,19 +164,30 @@ _srepr(x) = repr(x)
 _srepr(x::AbstractString) = x
 _srepr(x::AbstractChar) = string(x)
 _srepr(x::Enum) = string(x)
+@static if VERSION < v"1.2.0-DEV"
+    _srepr(x::Irrational{sym}) where {sym} = string(sym)
+end
 
 function printfmt(io::IO, fs::FormatSpec, x)
     cls = fs.cls
     ty = fs.typ
     if cls == 'i'
-        ix = Integer(x)
+        ix = x
+        try
+            ix = Integer(x)
+        catch
+        end
         ty == 'd' || ty == 'n' ? _pfmt_i(io, fs, ix, _Dec()) :
         ty == 'x' ? _pfmt_i(io, fs, ix, _Hex()) :
         ty == 'X' ? _pfmt_i(io, fs, ix, _HEX()) :
         ty == 'o' ? _pfmt_i(io, fs, ix, _Oct()) :
         _pfmt_i(io, fs, ix, _Bin())
     elseif cls == 'f'
-        fx = float(x)
+        fx = x
+        try
+            fx = float(x)
+        catch
+        end
         if isfinite(fx)
             ty == 'f' || ty == 'F' ? _pfmt_f(io, fs, fx) :
             ty == 'e' || ty == 'E' ? _pfmt_e(io, fs, fx) :

test/fmt.jl

@@ -20,8 +20,19 @@ i = 1234567
 @test fmt(i) == "1234567"
 @test fmt(i,:commas) == "1,234,567"
 
-@test_throws ErrorException fmt_default(Real)
-@test_throws ErrorException fmt_default(Complex)
+@test fmt(2 - 3im, 10) == "   2 - 3im"
+@test fmt(pi - 3im, 15, 2) == "  3.14 - 3.00im"
+
+@test fmt(3//4, 10) == "      3//4"
+@test fmt(1//2 + 6//2 * im, 15) == " 1//2 + 3//1*im"
+
+fmt_default!(Rational, 'f', prec = 2)
+fmt_default!(Format.ComplexRational, 'f', prec = 2)
+
+@test fmt(3//4, 10, 2) == "      0.75"
+@test fmt(3//4, 10, 1) == "       0.8"
+@test fmt(1//2 + 6//2 * im, 23) == "  0.500000 + 3.000000im"
+@test fmt(1//2 + 6//2 * im, 15, 2) == "  0.50 + 3.00im"
 
 fmt_default!(Int, :commas, width = 12)
 @test fmt(i) == "   1,234,567"
@@ -41,3 +52,9 @@ fmt_default!(UInt16, 'd', :commas)
 fmt_default!(UInt32, UInt16, width=20)
 @test fmt(0xfffff) == "           1,048,575"
 
+v = pi
+@test fmt(v) == "π"
+@test fmt(v; width=10) == "         π"
+
+v = MathConstants.eulergamma
+@test fmt(v, 10, 2) == "         γ"

test/fmtspec.jl

@@ -234,3 +234,17 @@ end
     @test pyfmt("*>5f", Inf) == "**Inf"
     @test pyfmt("⋆>5f", Inf) == "⋆⋆Inf"
 end
+
+@testset "Format Symbols (S) for Irrationals" begin
+    @test pyfmt(">10s", pi) == "         π"
+    @test pyfmt("10s", pi) == "π         "
+    @test pyfmt("3", MathConstants.eulergamma) == "  γ"
+    @test pyfmt("10.2f", MathConstants.eulergamma) == "      0.58"
+    @test pyfmt("<3s", MathConstants.e) == "ℯ  "
+end
+
+@testset "Format Symbols (S) for Irrationals" begin
+    pyfmt("10s", 3//4) == "3//4      "
+    pyfmt("10", 3//4) == "      3//4"
+    pyfmt("10.1f", 3//4) == "       0.8"
+end