Update AdjacencyGraph

Author: amontoison

src/coloring.jl

@@ -80,7 +80,7 @@ end
 
 """
     star_coloring(
-        g::AdjacencyGraph, vertices_in_order::AbstractVector, bicoloring::Bool, postprocessing::Bool;
+        g::AdjacencyGraph, vertices_in_order::AbstractVector, postprocessing::Bool;
         postprocessing_minimizes::Symbol=:all_colors, forced_colors::Union{AbstractVector,Nothing}=nothing
     )
 
@@ -109,7 +109,6 @@ The optional `forced_colors` keyword argument is used to enforce predefined vert
 function star_coloring(
     g::AdjacencyGraph{T},
     vertices_in_order::AbstractVector{<:Integer},
-    bicoloring::Bool,
     postprocessing::Bool;
     postprocessing_minimizes::Symbol=:all_colors,
     forced_colors::Union{AbstractVector{<:Integer},Nothing}=nothing,
@@ -170,7 +169,7 @@ function star_coloring(
     if postprocessing
         # Reuse the vector forbidden_colors to compute offsets during post-processing
         offsets = forbidden_colors
-        postprocess!(color, star_set, g, offsets, bicoloring, postprocessing_minimizes)
+        postprocess!(color, star_set, g, offsets, postprocessing_minimizes)
     end
     return color, star_set
 end
@@ -252,7 +251,7 @@ struct StarSet{T}
 end
 
 """
-    acyclic_coloring(g::AdjacencyGraph, vertices_in_order::AbstractVector, bicoloring::Bool, postprocessing::Bool;
+    acyclic_coloring(g::AdjacencyGraph, vertices_in_order::AbstractVector, postprocessing::Bool;
                      postprocessing_minimizes::Symbol=:all_colors)
 
 Compute an acyclic coloring of all vertices in the adjacency graph `g` and return a tuple `(color, tree_set)`, where
@@ -278,7 +277,6 @@ If `postprocessing=true`, some colors might be replaced with `0` (the "neutral"
 function acyclic_coloring(
     g::AdjacencyGraph{T},
     vertices_in_order::AbstractVector{<:Integer},
-    bicoloring::Bool,
     postprocessing::Bool;
     postprocessing_minimizes::Symbol=:all_colors,
 ) where {T<:Integer}
@@ -352,7 +350,7 @@ function acyclic_coloring(
     if postprocessing
         # Reuse the vector forbidden_colors to compute offsets during post-processing
         offsets = forbidden_colors
-        postprocess!(color, tree_set, g, offsets, bicoloring, postprocessing_minimizes)
+        postprocess!(color, tree_set, g, offsets, postprocessing_minimizes)
     end
     return color, tree_set
 end

src/graph.jl

@@ -227,6 +227,8 @@ The adjacency graph of a symmetric matrix `A ∈ ℝ^{n × n}` is `G(A) = (V, E)
 struct AdjacencyGraph{T<:Integer,augmented_graph}
     S::SparsityPatternCSC{T}
     edge_to_index::Vector{T}
+    bicoloring::Bool
+    original_size::Tuple{Int,Int}
 end
 
 Base.eltype(::AdjacencyGraph{T}) where {T} = T
@@ -235,15 +237,17 @@ function AdjacencyGraph(
     S::SparsityPatternCSC{T},
     edge_to_index::Vector{T}=build_edge_to_index(S);
     augmented_graph::Bool=false,
+    bicoloring::Bool=false,
+    original_size::Tuple{Int,Int}=size(S),    
 ) where {T}
-    return AdjacencyGraph{T,augmented_graph}(S, edge_to_index)
+    return AdjacencyGraph{T,augmented_graph}(S, edge_to_index, bicoloring, original_size)
 end
 
-function AdjacencyGraph(A::SparseMatrixCSC; augmented_graph::Bool=false)
+function AdjacencyGraph(A::SparseMatrixCSC; augmented_graph::Bool=false, original_size::Tuple{Int,Int}=size(A))
     return AdjacencyGraph(SparsityPatternCSC(A); augmented_graph)
 end
 
-function AdjacencyGraph(A::AbstractMatrix; augmented_graph::Bool=false)
+function AdjacencyGraph(A::AbstractMatrix; augmented_graph::Bool=false, original_size::Tuple{Int,Int}=size(A))
     return AdjacencyGraph(SparseMatrixCSC(A); augmented_graph)
 end
 

src/interface.jl

@@ -283,11 +283,10 @@ function _coloring(
     symmetric_pattern::Bool;
     forced_colors::Union{AbstractVector{<:Integer},Nothing}=nothing,
 )
-    ag = AdjacencyGraph(A; augmented_graph=false)
-    bicoloring = false
+    ag = AdjacencyGraph(A; augmented_graph=false, original_size=size(A))
     color_and_star_set_by_order = map(algo.orders) do order
         vertices_in_order = vertices(ag, order)
-        return star_coloring(ag, vertices_in_order, bicoloring, algo.postprocessing; forced_colors)
+        return star_coloring(ag, vertices_in_order, algo.postprocessing; forced_colors)
     end
     color, star_set = argmin(maximum ∘ first, color_and_star_set_by_order)
     if speed_setting isa WithResult
@@ -305,11 +304,10 @@ function _coloring(
     decompression_eltype::Type{R},
     symmetric_pattern::Bool,
 ) where {R}
-    ag = AdjacencyGraph(A; augmented_graph=false)
-    bicoloring = false
+    ag = AdjacencyGraph(A; augmented_graph=false, original_size=size(A))
     color_and_tree_set_by_order = map(algo.orders) do order
         vertices_in_order = vertices(ag, order)
-        return acyclic_coloring(ag, vertices_in_order, bicoloring, algo.postprocessing)
+        return acyclic_coloring(ag, vertices_in_order, algo.postprocessing)
     end
     color, tree_set = argmin(maximum ∘ first, color_and_tree_set_by_order)
     if speed_setting isa WithResult
@@ -329,13 +327,12 @@ function _coloring(
     forced_colors::Union{AbstractVector{<:Integer},Nothing}=nothing,
 ) where {R}
     A_and_Aᵀ, edge_to_index = bidirectional_pattern(A; symmetric_pattern)
-    ag = AdjacencyGraph(A_and_Aᵀ, edge_to_index; augmented_graph=true)
-    bicoloring = true
+    ag = AdjacencyGraph(A_and_Aᵀ, edge_to_index; augmented_graph=true, original_size=size(A))
     postprocessing_minimizes = algo.postprocessing_minimizes
     outputs_by_order = map(algo.orders) do order
         vertices_in_order = vertices(ag, order)
         _color, _star_set = star_coloring(
-            ag, vertices_in_order, bicoloring, algo.postprocessing; postprocessing_minimizes, forced_colors
+            ag, vertices_in_order, algo.postprocessing; postprocessing_minimizes, forced_colors
         )
         (_row_color, _column_color, _symmetric_to_row, _symmetric_to_column) = remap_colors(
             eltype(ag), _color, maximum(_color), size(A)...
@@ -378,12 +375,11 @@ function _coloring(
     symmetric_pattern::Bool,
 ) where {R}
     A_and_Aᵀ, edge_to_index = bidirectional_pattern(A; symmetric_pattern)
-    ag = AdjacencyGraph(A_and_Aᵀ, edge_to_index; augmented_graph=true)
-    bicoloring = true
+    ag = AdjacencyGraph(A_and_Aᵀ, edge_to_index; augmented_graph=true, original_size=size(A))
     postprocessing_minimizes = algo.postprocessing_minimizes
     outputs_by_order = map(algo.orders) do order
         vertices_in_order = vertices(ag, order)
-        _color, _tree_set = acyclic_coloring(ag, vertices_in_order, bicoloring, algo.postprocessing; postprocessing_minimizes)
+        _color, _tree_set = acyclic_coloring(ag, vertices_in_order, algo.postprocessing; postprocessing_minimizes)
         (_row_color, _column_color, _symmetric_to_row, _symmetric_to_column) = remap_colors(
             eltype(ag), _color, maximum(_color), size(A)...
         )

test/suitesparse.jl

@@ -146,7 +146,7 @@ what_table_41_42 = CSV.read(
         bicoloring = false
         postprocessing = false
         vertices_in_order = vertices(ag, NaturalOrder())
-        color_N, _ = star_coloring(ag, vertices_in_order, bicoloring, postprocessing)
+        color_N, _ = star_coloring(ag, vertices_in_order, postprocessing)
         @test_skip row[:KS1] <= length(unique(color_N)) <= row[:KS2]  # TODO: find better
         yield()
     end