better printing of sparse matrices?

[stevengj]

Compare:

julia> A = Diagonal(rand(1000))
1000×1000 Diagonal{Float64,Array{Float64,1}}:
 0.0341907   ⋅         ⋅         ⋅        …   ⋅         ⋅         ⋅      
  ⋅         0.758919   ⋅         ⋅            ⋅         ⋅         ⋅      
  ⋅          ⋅        0.700876   ⋅            ⋅         ⋅         ⋅      
  ⋅          ⋅         ⋅        0.453502      ⋅         ⋅         ⋅      
  ⋅          ⋅         ⋅         ⋅            ⋅         ⋅         ⋅      
  ⋅          ⋅         ⋅         ⋅        …   ⋅         ⋅         ⋅      
 ⋮                                        ⋱                              
  ⋅          ⋅         ⋅         ⋅            ⋅         ⋅         ⋅      
  ⋅          ⋅         ⋅         ⋅        …   ⋅         ⋅         ⋅      
  ⋅          ⋅         ⋅         ⋅            ⋅         ⋅         ⋅      
  ⋅          ⋅         ⋅         ⋅           0.489115   ⋅         ⋅      
  ⋅          ⋅         ⋅         ⋅            ⋅        0.791967   ⋅      
  ⋅          ⋅         ⋅         ⋅            ⋅         ⋅        0.164329

julia> sparse(A)
1000×1000 SparseMatrixCSC{Float64,Int64} with 1000 stored entries:
  [1   ,    1]  =  0.0341907
  [2   ,    2]  =  0.758919
  [3   ,    3]  =  0.700876
  [4   ,    4]  =  0.453502
  [5   ,    5]  =  0.560549
  [6   ,    6]  =  0.832382
  ⋮
  [995 ,  995]  =  0.270777
  [996 ,  996]  =  0.0664044
  [997 ,  997]  =  0.689441
  [998 ,  998]  =  0.489115
  [999 ,  999]  =  0.791967
  [1000, 1000]  =  0.164329

Why can't a SparseMatrixCSC be printed in the same way as the structured sparse-matrix types? It would be a heck of a lot more readable.

PS. On an unrelated note, I also notice that the SparseMatrixCSC output isn't setting the :typeinfo property of the IOContext, so it screws up e.g. #30575. Update: This is fixed by #30589.

[rfourquet]

Not kidding, I had the exact same thought earlier today while reviewing some sparse code!

[abraunst]

Note that for a matrix with density p, the probability of having all k shown entries to be zero is (1-p)^k which for p small behaves as exp(-k p). Assuming k~200 (about the number of 0.0 that julia fits in my terminal), in an arguably realistic scenario for an NxN matrix with N=10^6, p=5/N this probability is ~ 0.999. I think that in a good fraction of real cases all shown entries would be zero. So I don't think that the current representation is so bad. ;-)

[fredrikekre]

I think that in a good fraction of real cases all shown entries would be zero.

True, but the diagonal is quite often filled though.

[andreasnoack]

I also don't like the current printing. Another possibility that we discussed a few years ago was to print a text spy plot instead of the numerical values. Sparse matrices are often quite large and it can often be more interesting to see the distribution of non-zeros than a few of the elements.

[stevengj]

@abraunst, in real sparse matrices it's pretty rare to have a random distribution like that. One option would be to print a portion starting at the first nonzero entry.

[ViralBShah]

I think people working on PDEs and such have the structured sparse matrices, but the folks working on graphs usually don't have that structure.

I do agree that what we do today should be replaced and I also like the idea of the text spy plot.

What if the portion around the first nonzero entry is also extremely sparse? (you could easily have just 1 nonzero in there).

[StefanKarpinski]

We could use Braille patterns to print a fairly compact text spy plot: https://en.wikipedia.org/wiki/Braille_Patterns

[stevengj]

Yes, similar to https://github.com/Evizero/UnicodePlots.jl

[ViralBShah]

Off-topic - I would love to ship UnicodePlots in stdlib. That would also give us these spy plots for little effort.

[JeffBezanson]

Using output like Diagonal when all (or most?) of the matrix fits on the screen, then switching to a text spy plot for larger matrices would be ideal.

[pablosanjose]

Another possibility for the Diagonal-like form is to print the first and last nonzeroes together with their column and row indices, but in matrix form. Something similar to

julia> sparse(A)
1000×1000 SparseMatrixCSC{Float64,Int64} with 1000 stored entries:
_______|11 ______ 14 _______ 102 ______ 932 ____
27     |⋅         0.758919   ⋅          ⋅        
96     |0.389739  ⋅          ⋅          ⋅        
203    |⋅         ⋅          0.700876   ⋅        
701    |⋅         ⋅          ⋅          0.453502

with perhaps some form of color highlighting (or bold, or italic) for the column/row indices

[abraunst]

Another possibility for the Diagonal-like form is to print the first and last nonzeroes together with their column and row indices, but in matrix form. Something similar to

Seems promising, although it is not exactly clear what "first" and "last" indices are. For example, what would be the output for sparse(1:n,n:-1:1,fill(1,n),n,n) (antidiagonal) or a matrix with a + shape?
EDIT: sorry, the antidiagonal shape is easy

[pablosanjose]

Seems promising, although it is not exactly clear what "first" and "last" indices are.

I think it wouldn't be difficult to define this in a sensible way. For example take the N non-zeroes closest to the four corners of the matrix, and create a list of their respective rows and columns, removing duplicates.