compact show for operators (#172)

* compact show for operators

* reduce allocations

* remove unnecessary comma

* bump version to v0.6.15

* use show instead of print_array

* tests for rowrange/colrange

* bugfixes

* revert to using print_array

Author: jishnub

Project.toml

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

src/Operators/SubOperator.jl

@@ -181,12 +181,20 @@ function colstop(S::SubOperator{<:Any,<:Any,NTuple{2,UnitRange{Int}}},j::Integer
         min(n,findfirst(isequal(cs),kr))
     end
 end
-colstart(S::SubOperator{<:Any,<:Any,NTuple{2,UnitRange{Int}}},j::Integer) =
-    max(findfirst(parentindices(S)[1],colstart(parent(S),parentindices(S)[2][j])),1)
-rowstart(S::SubOperator{<:Any,<:Any,NTuple{2,UnitRange{Int}}},j::Integer) =
-    max(1,findfirst(parentindices(S)[2],rowstart(parent(S),parentindices(S)[1][j])))
-rowstop(S::SubOperator{<:Any,<:Any,NTuple{2,UnitRange{Int}}},j::Integer) =
-        findfirst(parentindices(S)[2],rowstop(parent(S),parentindices(S)[1][j]))
+function colstart(S::SubOperator{<:Any,<:Any,NTuple{2,UnitRange{Int}}},j::Integer)
+    cind = colstart(parent(S),parentindices(S)[2][j])
+    ind = findfirst(==(cind), parentindices(S)[1])
+    max(ind,1)
+end
+function rowstart(S::SubOperator{<:Any,<:Any,NTuple{2,UnitRange{Int}}},j::Integer)
+    rind = rowstart(parent(S),parentindices(S)[1][j])
+    ind = findfirst(==(rind), parentindices(S)[2])
+    max(1,ind)
+end
+function rowstop(S::SubOperator{<:Any,<:Any,NTuple{2,UnitRange{Int}}},j::Integer)
+    ind = rowstop(parent(S),parentindices(S)[1][j])
+    findfirst(==(ind), parentindices(S)[2])
+end
 
 
 # blocks don't change

src/Operators/general/OperatorLayout.jl

@@ -82,6 +82,7 @@ domain(P::AdjointOperator)=domain(P.op)
 bandwidths(P::AdjointOperator) = reverse(bandwidths(P.op))
 
 getindex(P::AdjointOperator,k::Integer,j::Integer) = conj(P.op[j,k])
+getindex(P::AdjointOperator,inds...) = adjoint(P.op[reverse(inds)...])
 
 function BandedMatrix(S::SubOperator{T,TO}) where {T,TO<:AdjointOperator}
     kr,jr=parentindices(S)

src/show.jl

@@ -40,13 +40,17 @@ Base.show(io::IO, N::PrintShow) = print(io, N.c)
 
 show(io::IO, B::Operator; kw...) = summary(io, B)
 
-function show(io::IO, ::MIME"text/plain", B::Operator;header::Bool=true)
+function show(io::IO, mimetype::MIME"text/plain", @nospecialize(B::Operator); header::Bool=true)
     header && summary(io, B)
     dsp = domainspace(B)
 
+    sz1_B, sz2_B = size(B)
+
+    iocompact = haskey(io, :compact) ? io : IOContext(io, :compact => true)
+
     if !isambiguous(domainspace(B)) && (eltype(B) <: Number)
-        println()
-        if isbanded(B) && isinf(size(B,1)) && isinf(size(B,2))
+        println(io)
+        if isbanded(B) && isinf(sz1_B) && isinf(sz2_B)
             BM=B[1:10,1:10]
 
             M=Matrix{Union{eltype(B), PrintShow}}(undef,11,11)
@@ -62,49 +66,56 @@ function show(io::IO, ::MIME"text/plain", B::Operator;header::Bool=true)
                 M[end,j]=PrintShow('⋱')
             end
 
-            print_array(io, M)
-        elseif isinf(size(B,1)) && isinf(size(B,2))
+            print_array(iocompact, M)
+        elseif isinf(sz1_B) && isinf(sz2_B)
             BM=B[1:10,1:10]
 
             M=Matrix{Union{eltype(B), PrintShow}}(undef,11,11)
-            for k=1:10,j=1:10
-                M[k,j]=BM[k,j]
+            for I in CartesianIndices(axes(BM))
+                M[I]=BM[Tuple(I)...] # not certain if indexing with CartesianIndex is implemented
             end
 
             M[1,end]=PrintShow('⋯')
             M[end,1]=PrintShow('⋮')
 
             for k=2:11
-                M[k,end]=M[end,k]=PrintShow('⋱')
+                M[k,end]=PrintShow('⋱')
+            end
+            for k=2:11
+                M[end,k]=PrintShow('⋱')
             end
 
-            print_array(io, M)
-        elseif isinf(size(B,1))
-            BM=B[1:10,1:size(B,2)]
+            print_array(iocompact, M)
+        elseif isinf(sz1_B)
+            sz2int = Int(sz2_B)::Int
+            BM=B[1:10,1:sz2int]
 
-            M=Matrix{Union{eltype(B), PrintShow}}(undef,11,size(B,2))
-            for k=1:10,j=1:size(B,2)
-                M[k,j]=BM[k,j]
+            M=Matrix{Union{eltype(B), PrintShow}}(undef,11,sz2int)
+            for I in CartesianIndices(axes(BM))
+                M[I]=BM[Tuple(I)...]
             end
-            for k=1:size(B,2)
+            for k=1:sz2int
                 M[end,k]=PrintShow('⋮')
             end
 
-            print_array(io, M)
-        elseif isinf(size(B,2))
-            BM=B[1:size(B,1),1:10]
+            print_array(iocompact, M)
+        elseif isinf(sz2_B)
+            sz1int = Int(sz1_B)::Int
+            BM=B[1:sz1int,1:10]
 
-            M=Matrix{Union{eltype(B), PrintShow}}(undef,size(B,1),11)
-            for k=1:size(B,1),j=1:10
-                M[k,j]=BM[k,j]
+            M=Matrix{Union{eltype(B), PrintShow}}(undef,sz1int,11)
+            for I in CartesianIndices(axes(BM))
+                M[I]=BM[Tuple(I)...]
             end
-            for k=1:size(B,1)
+            for k=1:sz1int
                 M[k,end]=PrintShow('⋯')
             end
 
-            print_array(io, M)
+            print_array(iocompact, M)
         else
-            print_array(io, AbstractMatrix(B)[1:size(B,1),1:size(B,2)])
+            sz1int = Int(sz1_B)::Int
+            sz2int = Int(sz2_B)::Int
+            print_array(iocompact, AbstractMatrix(B)[1:sz1int,1:sz2int])
         end
     end
 end

test/SpacesTest.jl

@@ -2,6 +2,7 @@ using ApproxFunBase, Test
 import ApproxFunBase: PointSpace, HeavisideSpace, PiecewiseSegment, dimension, Vec, checkpoints
 using ApproxFunOrthogonalPolynomials
 using StaticArrays
+using BandedMatrices: rowrange, colrange
 
 @testset "Spaces" begin
     @testset "PointSpace" begin
@@ -340,5 +341,12 @@ using StaticArrays
             @test Derivative(Chebyshev()) != Derivative(Chebyshev(), 2)
             @test Derivative(Chebyshev()) != Derivative(Legendre())
         end
+
+        @testset "SubOperator" begin
+            D = Derivative(Chebyshev())
+            S = @view D[1:10, 1:10]
+            @test rowrange(S, 1) == 2:2
+            @test colrange(S, 2) == 1:1
+        end
     end
 end

test/show.jl

@@ -1,4 +1,5 @@
 @testset "show" begin
+	io = IOBuffer()
 	@testset "Domain" begin
 		@testset "Segment" begin
 			s = Segment(0, 1)
@@ -31,16 +32,37 @@
 	@testset "Operator" begin
 		@testset "Derivative" begin
 			D = Derivative()
-			dsum = ApproxFunBase.summarystr(D)
-			@test repr(D) == dsum
-			io = IOBuffer()
+			summarystr = ApproxFunBase.summarystr(D)
+			@test repr(D) == summarystr
 			show(io, MIME"text/plain"(), D)
-			@test contains(String(take!(io)), dsum)
+			@test contains(String(take!(io)), summarystr)
+
+			D = Derivative(Chebyshev())
+			summarystr = ApproxFunBase.summarystr(D)
+			show(io, MIME"text/plain"(), D)
+			@test contains(String(take!(io)), summarystr)
+		end
+		@testset "SubOperator" begin
+			D = Derivative(Chebyshev())
+			S = @view D[1:10, 1:10]
+			summarystr = ApproxFunBase.summarystr(S)
+			show(io, MIME"text/plain"(), S)
+			@test contains(String(take!(io)), summarystr)
+		end
+		@testset "Evaluation" begin
+			E = Evaluation(Chebyshev(), 0)
+			summarystr = ApproxFunBase.summarystr(E)
+			show(io, MIME"text/plain"(), E)
+			@test contains(String(take!(io)), summarystr)
+
+			EA = Evaluation(Chebyshev(), 0)'
+			summarystr = ApproxFunBase.summarystr(EA)
+			show(io, MIME"text/plain"(), EA)
+			@test contains(String(take!(io)), summarystr)
 		end
 		@testset "QuotientSpace" begin
 			Q = QuotientSpace(Dirichlet(ConstantSpace(0..1)))
 			@test startswith(repr(Q), "ConstantSpace(0..1) /")
-			io = IOBuffer()
 			show(io, MIME"text/plain"(), Q)
 			s = String(take!(io))
 			@test startswith(s, "ConstantSpace(0..1) /")