Remove spokes and nb_spokes

Author: amontoison

src/coloring.jl

@@ -88,7 +88,6 @@ function star_coloring(g::AdjacencyGraph, order::AbstractOrder; postprocessing::
     treated = zeros(Int, nv)
     star = Vector{Int}(undef, ne)
     hub = Int[]  # one hub for each star, including the trivial ones
-    nb_spokes = Int[]  # number of spokes for each star
     vertices_in_order = vertices(g, order)
 
     # edge_to_index gives an index for each edge
@@ -142,12 +141,12 @@ function star_coloring(g::AdjacencyGraph, order::AbstractOrder; postprocessing::
                 break
             end
         end
-        _update_stars!(star, hub, nb_spokes, g, v, color, first_neighbor, edge_to_index)
+        _update_stars!(star, hub, g, v, color, first_neighbor, edge_to_index)
     end
-    star_set = StarSet(g, star, hub, nb_spokes, color, edge_to_index)
+    star_set = StarSet(star, hub)
     if postprocessing
         # Reuse the vector forbidden_colors to compute offsets during post-processing
-        postprocess!(color, star_set, g, forbidden_colors)
+        postprocess!(color, star_set, g, forbidden_colors, edge_to_index)
     end
     return color, star_set, edge_to_index
 end
@@ -174,7 +173,6 @@ function _update_stars!(
     # modified
     star::AbstractVector{<:Integer},
     hub::AbstractVector{<:Integer},
-    nb_spokes::AbstractVector{<:Integer},
     # not modified
     g::AdjacencyGraph,
     v::Integer,
@@ -193,7 +191,6 @@ function _update_stars!(
                 index_wx = edge_to_index[S.colptr[w] + ix - 1]
                 star_wx = star[index_wx]
                 hub[star_wx] = w  # this may already be true
-                nb_spokes[star_wx] += 1
                 star[index_vw] = star_wx
                 x_exists = true
                 break
@@ -204,11 +201,9 @@ function _update_stars!(
             if p == v && q != w  # vw, vq ∈ E and color[w] = color[q]
                 star_vq = star[index_pq]
                 hub[star_vq] = v  # this may already be true
-                nb_spokes[star_vq] += 1
                 star[index_vw] = star_vq
             else  # vw forms a new star
                 push!(hub, -max(v, w))  # star is trivial (composed only of two vertices) so we set the hub to a negative value, but it allows us to choose one of the two vertices
-                push!(nb_spokes, 1)
                 star[index_vw] = length(hub)
             end
         end
@@ -230,50 +225,6 @@ struct StarSet
     star::Vector{Int}
     "a mapping from star indices to their hub (undefined hubs for single-edge stars are the negative value of one of the vertices, picked arbitrarily)"
     hub::Vector{Int}
-    "a mapping from star indices to the vector of their spokes"
-    spokes::Vector{Vector{Int}}
-end
-
-function StarSet(
-    g::AdjacencyGraph,
-    star::Vector{Int},
-    hub::Vector{Int},
-    nb_spokes::Vector{Int},
-    color::Vector{Int},
-    edge_to_index::Vector{Int},
-)
-    S = pattern(g)
-    n = S.n
-
-    # Create a list of spokes for each star, preallocating their sizes based on nb_spokes
-    spokes = [Vector{Int}(undef, ns) for ns in nb_spokes]
-
-    # Reuse nb_spokes as counters to track the current index while filling the spokes
-    fill!(nb_spokes, 0)
-
-    rvS = rowvals(S)
-    for j in axes(S, 2)
-        for k in nzrange(S, j)
-            i = rvS[k]
-            if i > j
-                index_ij = edge_to_index[k]
-                s = star[index_ij]
-                h = abs(hub[s])
-                nb_spokes[s] += 1
-                index = nb_spokes[s]
-
-                # Assign the non-hub vertex (spoke) to the correct position in spokes
-                if i == h
-                    # i is the hub and j is the spoke
-                    spokes[s][index] = j
-                else  # j == h
-                    # j is the hub and i is the spoke
-                    spokes[s][index] = i
-                end
-            end
-        end
-    end
-    return StarSet(star, hub, spokes)
 end
 
 """
@@ -384,7 +335,7 @@ function acyclic_coloring(g::AdjacencyGraph, order::AbstractOrder; postprocessin
     tree_set = TreeSet(g, forest, edge_to_index)
     if postprocessing
         # Reuse the vector forbidden_colors to compute offsets during post-processing
-        postprocess!(color, tree_set, g, forbidden_colors)
+        postprocess!(color, tree_set, g, forbidden_colors, edge_to_index)
     end
     return color, tree_set
 end
@@ -612,6 +563,7 @@ function postprocess!(
     star_or_tree_set::Union{StarSet,TreeSet},
     g::AdjacencyGraph,
     offsets::Vector{Int},
+    edge_to_index::Vector{Int},
 )
     (; S) = g
     # flag which colors are actually used during decompression
@@ -629,34 +581,41 @@ function postprocess!(
 
     if star_or_tree_set isa StarSet
         # only the colors of the hubs are used
-        (; hub, spokes) = star_or_tree_set
+        (; star, hub) = star_or_tree_set
         nb_trivial_stars = 0
 
         # Iterate through all non-trivial stars
         for s in eachindex(hub)
-            j = hub[s]
-            if j > 0
-                color_used[color[j]] = true
+            h = hub[s]
+            if h > 0
+                color_used[color[h]] = true
             else
                 nb_trivial_stars += 1
             end
         end
 
         # Process the trivial stars (if any)
+        # TODO: Should we compute "compressed_indices" in the same time?
         if nb_trivial_stars > 0
-            for s in eachindex(hub)
-                j = hub[s]
-                if j < 0
-                    i = spokes[s][1]
-                    j = abs(j)
-                    if color_used[color[i]]
-                        # Make i the hub to avoid possibly adding one more used color
-                        # Switch it with the (only) spoke
-                        hub[s] = i
-                        spokes[s][1] = j
-                    else
-                        # Keep j as the hub
-                        color_used[color[j]] = true
+            rvS = rowvals(S)
+            for j in axes(S, 2)
+                for k in nzrange(S, j)
+                    i = rvS[k]
+                    if i > j
+                        index_ij = edge_to_index[k]
+                        s = star[index_ij]
+                        h = hub[s]
+                        if h < 0
+                            h = abs(h)
+                            spoke = h == j ? i : j
+                            if color_used[color[spoke]]
+                                # Switch the hub and the spoke to possibly avoid adding one more used color
+                                hub[s] = spoke
+                            else
+                                # Keep the current hub
+                                color_used[color[h]] = true
+                            end
+                        end
                     end
                 end
             end