Respond to PR comments.

Author: samuelsonric

ext/SparseMatrixColoringsCliqueTreesExt.jl

@@ -1,34 +1,22 @@
 module SparseMatrixColoringsCliqueTreesExt
 
-using CliqueTrees: CliqueTrees
-using SparseArrays
-using SparseMatrixColorings:
-    SparseMatrixColorings, AdjacencyGraph, BipartiteGraph, PerfectEliminationOrder, pattern
+import CliqueTrees: permutation, LexBFS, MCS
+import SparseArrays: SparseMatrixCSC, rowvals, nnz
+import SparseMatrixColorings:
+    AdjacencyGraph, BipartiteGraph, PerfectEliminationOrder, pattern, vertices
 
-function SparseMatrixColorings.vertices(
-    g::AdjacencyGraph{T}, order::PerfectEliminationOrder
-) where {T}
+function vertices(g::AdjacencyGraph{T}, order::PerfectEliminationOrder) where {T}
     S = pattern(g)
 
     # construct matrix with sparsity pattern S
     M = SparseMatrixCSC{Bool,T}(size(S)..., S.colptr, rowvals(S), ones(Bool, nnz(S)))
 
-    # can also use alg=CliqueTrees.LexBFS()
-    order, _ = CliqueTrees.permutation(M; alg=CliqueTrees.MCS())
-
-    return reverse!(order)
-end
-
-function SparseMatrixColorings.vertices(
-    bg::BipartiteGraph{T}, ::Val{side}, order::PerfectEliminationOrder
-) where {T,side}
-    S = pattern(bg, Val(side))
-
-    # construct matrix with sparsity pattern S
-    M = SparseMatrixCSC{Bool,T}(size(S)..., S.colptr, rowvals(S), ones(Bool, nnz(S)))
-
-    # can also use alg=CliqueTrees.LexBFS()
-    order, _ = CliqueTrees.permutation(M; alg=CliqueTrees.MCS())
+    # construct a perfect elimination order
+    # self-loops are ignored
+    # we can also use alg=LexBFS()
+    # - time complexity: O(|V| + |E|)
+    # - space complexity: O(|V| + |E|)
+    order, _ = permutation(M; alg=MCS())
 
     return reverse!(order)
 end

src/order.jl

@@ -305,10 +305,10 @@ const DynamicLargestFirst = DynamicDegreeBasedOrder{:forward,:low2high}
 """
     PerfectEliminationOrder
 
-Instance of [`AbstractOrder`](@ref) which sorts the vertices of a chordal graph in a perfect elimination order.
+A linear-time ordering code for symmetric graphs. On [chordal graphs](https://en.wikipedia.org/wiki/Chordal_graph), the code computes a perfect elimination ordering. Otherwise, it computes a suboptimal ordering.
 
 !!! danger
-    This order is implemented as a package extension and requires loading CliqueTrees.jl.
+    This order is implemented as a package extension and requires loading [CliqueTrees.jl](https://github.com/AlgebraicJulia/CliqueTrees.jl).
 
 # References
 

test/order.jl

@@ -115,16 +115,24 @@ end;
 end;
 
 @testset "PerfectEliminationOrder" begin
-    problem1 = ColoringProblem(; structure=:symmetric, partition=:column)
-    problem2 = ColoringProblem(; structure=:nonsymmetric, partition=:column)
+    problem = ColoringProblem(; structure=:symmetric, partition=:column)
     algorithm = GreedyColoringAlgorithm(
         PerfectEliminationOrder(); decompression=:substitution
     )
 
+    # band graphs
     for (n, m) in ((800, 80), (400, 40), (200, 20), (100, 10))
-        perm = randperm(n)
+        perm = randperm(rng, n)
         matrix = permute!(sparse(Symmetric(brand(n, n, m, 0), :L)), perm, perm)
-        @test ncolors(coloring(matrix, problem1, algorithm)) == 1m + 1
-        @test ncolors(coloring(matrix, problem2, algorithm)) == 2m + 1
+        π = vertices(AdjacencyGraph(matrix), PerfectEliminationOrder())
+        @test isperm(π)
+        @test ncolors(coloring(matrix, problem, algorithm)) == m + 1
+    end
+
+    # random graphs
+    for (n, p) in Iterators.product(20:20:100, 0.0:0.1:0.2)
+        matrix = sparse(Symmetric(sprand(rng, Bool, n, n, p)))
+        π = vertices(AdjacencyGraph(matrix), PerfectEliminationOrder())
+        @test isperm(π)
     end
 end