Move show methods from ApproxFun (#122)

* move show methods from ApproxFun

* version bump to v0.6

Author: jishnub

Project.toml

@@ -1,6 +1,6 @@
 name = "ApproxFunBase"
 uuid = "fbd15aa5-315a-5a7d-a8a4-24992e37be05"
-version = "0.5.15"
+version = "0.6.0"
 
 [deps]
 AbstractFFTs = "621f4979-c628-5d54-868e-fcf4e3e8185c"

src/ApproxFunBase.jl

@@ -114,5 +114,6 @@ include("Spaces/Spaces.jl")
 include("hacks.jl")
 include("testing.jl")
 include("specialfunctions.jl")
+include("show.jl")
 
 end #module

src/show.jl

@@ -0,0 +1,173 @@
+## Fun
+
+show(io::IO, ::MIME"text/plain", f::Fun) = show(io, f)
+
+function show(io::IO, f::Fun)
+    print(io,"Fun(")
+    show(io,space(f))
+    print(io,", ")
+    show(io,coefficients(f))
+    print(io,")")
+end
+
+show(io::IO,f::Fun{<:ConstantSpace{AnyDomain}}) =
+    print(io,"$(convert(Number,f)) anywhere")
+
+show(io::IO,f::Fun{<:ConstantSpace}) =
+    print(io,"$(convert(Number,f)) on $(domain(f))")
+
+## MultivariateFun
+
+show(io::IO, ::MIME"text/plain", f::MultivariateFun) = show(io, f)
+
+function show(io::IO,L::LowRankFun)
+    print(io,"LowRankFun on ",space(L)," of rank ",rank(L),".")
+end
+
+function show(io::IO,P::ProductFun)
+    print(io,"ProductFun on ",space(P),".")
+end
+
+## Operator
+
+summarystr(B::Operator) = string(typeof(B).name.name, " : ", domainspace(B), " → ", rangespace(B))
+summary(io::IO, B::Operator) = print(io, summarystr(B))
+
+struct PrintShow
+    str
+end
+Base.show(io::IO,N::PrintShow) = print(io,N.str)
+
+show(io::IO, B::Operator) = summary(io, B)
+
+function show(io::IO, ::MIME"text/plain", B::Operator;header::Bool=true)
+    header && summary(io, B)
+    dsp = domainspace(B)
+
+    if !isambiguous(domainspace(B)) && (eltype(B) <: Number)
+        println()
+        if isbanded(B) && isinf(size(B,1)) && isinf(size(B,2))
+            BM=B[1:10,1:10]
+
+            M=Matrix{Any}(undef,11,11)
+            fill!(M,PrintShow("⋅"))
+            for j = 1:size(BM,2),k = colrange(BM,j)
+                M[k,j]=BM[k,j]
+            end
+
+            for k=max(1,11-bandwidth(B,2)):11
+                M[k,end]=PrintShow("⋱")
+            end
+            for j=max(1,11-bandwidth(B,1)):10
+                M[end,j]=PrintShow("⋱")
+            end
+
+            print_array(io, M)
+        elseif isinf(size(B,1)) && isinf(size(B,2))
+            BM=B[1:10,1:10]
+
+            M=Matrix{Any}(undef,11,11)
+            for k=1:10,j=1:10
+                M[k,j]=BM[k,j]
+            end
+
+            M[1,end]=PrintShow("⋯")
+            M[end,1]=PrintShow("⋮")
+
+            for k=2:11
+                M[k,end]=M[end,k]=PrintShow("⋱")
+            end
+
+            print_array(io, M)
+        elseif isinf(size(B,1))
+            BM=B[1:10,1:size(B,2)]
+
+            M=Matrix{Any}(undef,11,size(B,2))
+            for k=1:10,j=1:size(B,2)
+                M[k,j]=BM[k,j]
+            end
+            for k=1:size(B,2)
+                M[end,k]=PrintShow("⋮")
+            end
+
+            print_array(io, M)
+        elseif isinf(size(B,2))
+            BM=B[1:size(B,1),1:10]
+
+            M=Matrix{Any}(undef,size(B,1),11)
+            for k=1:size(B,1),j=1:10
+                M[k,j]=BM[k,j]
+            end
+            for k=1:size(B,1)
+                M[k,end]=PrintShow("⋯")
+            end
+
+            print_array(io, M)
+        else
+            print_array(io, AbstractMatrix(B)[1:size(B,1),1:size(B,2)])
+        end
+    end
+end
+
+## Space
+
+function show(io::IO, S::PointSpace)
+    print(io, "PointSpace(")
+    show(io, points(S))
+    print(io,")")
+end
+
+function show(io::IO,s::QuotientSpace)
+    show(io,s.space)
+    print(io," /\n")
+    show(io,s.bcs;header=false)
+end
+
+
+function show(io::IO,ss::SumSpace)
+    s = components(ss)
+    show(io,s[1])
+    for sp in s[2:end]
+        print(io,"⊕")
+        show(io,sp)
+    end
+end
+
+
+function show(io::IO,ss::PiecewiseSpace)
+    s = components(ss)
+    show(io,s[1])
+    for sp in s[2:end]
+        print(io,"⨄")
+        show(io,sp)
+    end
+end
+
+summarystr(ss::ArraySpace) = string(Base.dims2string(length.(axes(ss))), " ArraySpace")
+summary(io::IO, ss::ArraySpace) = print(io, summarystr(ss))
+function show(io::IO,ss::ArraySpace;header::Bool=true)
+    header && print(io,summarystr(ss)*":\n")
+    show(io, ss.spaces)
+end
+
+function show(io::IO,s::TensorSpace)
+    d = length(s.spaces)
+    for i=1:d-1
+        show(io,s.spaces[i])
+        print(io,"⊗")
+    end
+    show(io,s.spaces[d])
+end
+
+function show(io::IO,s::SubSpace)
+    print(io,s.space)
+    print(io,"|")
+    show(io,s.indexes)
+end
+
+show(io::IO,::ConstantSpace{AnyDomain}) = print(io,"ConstantSpace")
+show(io::IO,S::ConstantSpace) = print(io,"ConstantSpace($(domain(S)))")
+
+## Segment
+
+show(io::IO,d::Segment) = print(io,"the segment [$(leftendpoint(d)),$(rightendpoint(d))]")

test/runtests.jl

@@ -165,3 +165,4 @@ end
 end
 
 @time include("ETDRK4Test.jl")
+include("show.jl")

test/show.jl

@@ -0,0 +1,41 @@
+@testset "show" begin
+	@testset "Domain" begin
+		@testset "Segment" begin
+			s = Segment(0, 1)
+			@test contains(repr(s), repr(leftendpoint(s)))
+			@test contains(repr(s), repr(rightendpoint(s)))
+		end
+	end
+	@testset "Space" begin
+		@testset "ConstantSpace" begin
+			@test contains(repr(ConstantSpace()), "ConstantSpace")
+			c = ConstantSpace(0..1)
+			@test contains(repr(c), "ConstantSpace")
+			@test contains(repr(c), repr(domain(c)))
+		end
+	end
+	@testset "Fun" begin
+		f = Fun(PointSpace(1:3), [1,2,3])
+		s = repr(f)
+		@test startswith(s, "Fun")
+		@test contains(s, repr(space(f)))
+		@test contains(s, repr(coefficients(f)))
+
+		f = Fun(ConstantSpace(0..1), [2])
+		@test contains(repr(f), repr(coefficient(f, 1)))
+		@test contains(repr(f), repr(domain(f)))
+
+		f = Fun(ConstantSpace(), [2])
+		@test contains(repr(f), repr(coefficient(f, 1)))
+	end
+	@testset "Operator" begin
+		@testset "Derivative" begin
+			D = Derivative()
+			dsum = ApproxFunBase.summarystr(D)
+			@test repr(D) == dsum
+			io = IOBuffer()
+			show(io, MIME"text/plain"(), D)
+			@test contains(String(take!(io)), dsum)
+		end
+	end
+end