Change show(::MatchedSystemStructure) to use fewer colors.

This includes the following changes for `Base.show(::IO,
::MatchedSystemStructure)`:
  - var ⇔ eq matches are marked with underline (previously, yellow)
  - (un)solvable vars/eqs are printed in dark gray and white,
    respectively (previously, white/yellow)
  - the ∫ symbol is now printed without coloring
  - A separator has been added for the var/eq sides of the table

These changes are made to encode less semantic information using
colors, so that can colors instead be used to present a unified
"diff" view of these objects. The new format is arguably more
boring, but IMO is also easier to scan for information.

Author: topolarity

src/bipartite_graph.jl

@@ -212,21 +212,21 @@ end
 
 struct HighlightInt
     i::Int
-    highlight::Union{Symbol, Nothing}
+    highlight::Symbol
+    underline::Bool
 end
 Base.typeinfo_implicit(::Type{HighlightInt}) = true
-
 function Base.show(io::IO, hi::HighlightInt)
-    if hi.highlight !== nothing
-        printstyled(io, hi.i, color = hi.highlight)
+    if hi.underline
+        printstyled(io, hi.i, color = hi.highlight, underline = true)
     else
-        print(io, hi.i)
+        printstyled(io, hi.i, color = hi.highlight)
     end
 end
 
 function Base.show(io::IO, l::BipartiteAdjacencyList)
     if l.match === true
-        printstyled(io, "∫ ", color = :light_blue, bold = true)
+        printstyled(io, "∫ ")
     end
     if l.u === nothing
         printstyled(io, '⋅', color = :light_black)
@@ -238,26 +238,30 @@ function Base.show(io::IO, l::BipartiteAdjacencyList)
         match = l.match
         isa(match, Bool) && (match = unassigned)
         function choose_color(i)
-            i in l.highligh_u ? (i == match ? :light_yellow : :green) :
-            (i == match ? :yellow : nothing)
+            i in l.highligh_u ? :default : :light_black
         end
         if !isempty(setdiff(l.highligh_u, l.u))
             # Only for debugging, shouldn't happen in practice
-            print(io, map(union(l.u, l.highligh_u)) do i
-                      HighlightInt(i, !(i in l.u) ? :light_red : choose_color(i))
+            print(io,
+                  map(union(l.u, l.highligh_u)) do i
+                      HighlightInt(i, !(i in l.u) ? :light_red : choose_color(i),
+                                   i == match)
                   end)
         else
             print(io, map(l.u) do i
-                      HighlightInt(i, choose_color(i))
+                      HighlightInt(i, choose_color(i), i == match)
                   end)
         end
     end
 end
 
 struct Label
     s::String
+    c::Symbol
 end
-Base.show(io::IO, l::Label) = print(io, l.s)
+Label(s::AbstractString) = Label(s, :nothing)
+Label(x::Integer) = Label(string(x))
+Base.show(io::IO, l::Label) = printstyled(io, l.s, color = l.c)
 
 struct BipartiteGraphPrintMatrix <:
        AbstractMatrix{Union{Label, Int, BipartiteAdjacencyList}}

src/systems/systemstructure.jl

@@ -12,7 +12,7 @@ import ..ModelingToolkit: isdiffeq, var_from_nested_derivative, vars!, flatten,
                           equations, isirreducible, input_timedomain, TimeDomain,
                           VariableType, getvariabletype
 using ..BipartiteGraphs
-import ..BipartiteGraphs: invview, complete
+import ..BipartiteGraphs: invview, complete, HighlightInt
 using Graphs
 using UnPack
 using Setfield
@@ -386,14 +386,14 @@ end
 
 using .BipartiteGraphs: Label, BipartiteAdjacencyList
 struct SystemStructurePrintMatrix <:
-       AbstractMatrix{Union{Label, Int, BipartiteAdjacencyList}}
+       AbstractMatrix{Union{Label, BipartiteAdjacencyList}}
     bpg::BipartiteGraph
     highlight_graph::BipartiteGraph
     var_to_diff::DiffGraph
     eq_to_diff::DiffGraph
     var_eq_matching::Union{Matching, Nothing}
 end
-Base.size(bgpm::SystemStructurePrintMatrix) = (max(nsrcs(bgpm.bpg), ndsts(bgpm.bpg)) + 1, 5)
+Base.size(bgpm::SystemStructurePrintMatrix) = (max(nsrcs(bgpm.bpg), ndsts(bgpm.bpg)) + 1, 7)
 function compute_diff_label(diff_graph, i)
     di = i - 1 <= length(diff_graph) ? diff_graph[i - 1] : nothing
     ii = i - 1 <= length(invview(diff_graph)) ? invview(diff_graph)[i - 1] : nothing
@@ -404,13 +404,18 @@ end
 function Base.getindex(bgpm::SystemStructurePrintMatrix, i::Integer, j::Integer)
     checkbounds(bgpm, i, j)
     if i <= 1
-        return (Label.(("#", "∂ₜ", "eq", "∂ₜ", "v")))[j]
+        return (Label.(("#", "∂ₜ", "eq", "", "#", "∂ₜ", "v")))[j]
+    elseif j == 4
+        colors = Base.text_colors
+        return Label("|", :light_black)
     elseif j == 2
         return compute_diff_label(bgpm.eq_to_diff, i)
-    elseif j == 4
+    elseif j == 6
         return compute_diff_label(bgpm.var_to_diff, i)
     elseif j == 1
-        return i - 1
+        return Label((i - 1 <= length(bgpm.eq_to_diff)) ? string(i - 1) : "")
+    elseif j == 5
+        return Label((i - 1 <= length(bgpm.var_to_diff)) ? string(i - 1) : "")
     elseif j == 3
         return BipartiteAdjacencyList(i - 1 <= nsrcs(bgpm.bpg) ?
                                       𝑠neighbors(bgpm.bpg, i - 1) : nothing,
@@ -421,7 +426,7 @@ function Base.getindex(bgpm::SystemStructurePrintMatrix, i::Integer, j::Integer)
                                       bgpm.var_eq_matching !== nothing &&
                                       (i - 1 <= length(invview(bgpm.var_eq_matching))) ?
                                       invview(bgpm.var_eq_matching)[i - 1] : unassigned)
-    elseif j == 5
+    elseif j == 7
         match = unassigned
         if bgpm.var_eq_matching !== nothing && i - 1 <= length(bgpm.var_eq_matching)
             match = bgpm.var_eq_matching[i - 1]