Make elimination algorithm parametric

Author: gdalle

ext/SparseMatrixColoringsCliqueTreesExt.jl

@@ -1,10 +1,12 @@
 module SparseMatrixColoringsCliqueTreesExt
 
-import CliqueTrees: permutation, LexBFS, MCS
+import CliqueTrees: permutation, EliminationAlgorithm, MCS
 import SparseArrays: SparseMatrixCSC, rowvals, nnz
 import SparseMatrixColorings:
     AdjacencyGraph, BipartiteGraph, PerfectEliminationOrder, pattern, vertices
 
+PerfectEliminationOrder() = PerfectEliminationOrder(MCS())
+
 function vertices(g::AdjacencyGraph{T}, order::PerfectEliminationOrder) where {T}
     S = pattern(g)
 
@@ -13,10 +15,7 @@ function vertices(g::AdjacencyGraph{T}, order::PerfectEliminationOrder) where {T
 
     # 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())
+    order, _ = permutation(M; alg=order.elimination_algorithm)
 
     return reverse!(order)
 end

src/order.jl

@@ -14,6 +14,7 @@ Depending on how the vertices are ordered, the number of colors necessary may va
 - [`IncidenceDegree`](@ref) (experimental)
 - [`SmallestLast`](@ref) (experimental)
 - [`DynamicLargestFirst`](@ref) (experimental)
+- [`PerfectEliminationOrder`](@ref)
 """
 abstract type AbstractOrder end
 
@@ -303,10 +304,12 @@ Instance of [`AbstractOrder`](@ref) which sorts vertices from lowest to highest
 const DynamicLargestFirst = DynamicDegreeBasedOrder{:forward,:low2high}
 
 """
-    PerfectEliminationOrder
+    PerfectEliminationOrder(elimination_algorithm=CliqueTrees.MCS())
 
 Instance of [`AbstractOrder`](@ref) which computes a perfect elimination ordering when the underlying graph is [chordal](https://en.wikipedia.org/wiki/Chordal_graph). For non-chordal graphs, it computes a suboptimal ordering.
 
+The `elimination_algorithm` must be an instance of `CliqueTrees.EliminationAlgorithm`.
+
 !!! warning
     This order can only be applied for symmetric or bidirectional coloring problems.
 
@@ -317,4 +320,6 @@ Instance of [`AbstractOrder`](@ref) which computes a perfect elimination orderin
 
 - [Simple Linear-Time Algorithms to Test Chordality of Graphs, Test Acyclicity of Hypergraphs, and Selectively Reduce Acyclic Hypergraphs](https://epubs.siam.org/doi/10.1137/0213035), Tarjan and Yannakakis (1984)
 """
-struct PerfectEliminationOrder <: AbstractOrder end
+struct PerfectEliminationOrder{E} <: AbstractOrder
+    elimination_algorithm::E
+end

test/order.jl

@@ -116,8 +116,9 @@ end;
 
 @testset "PerfectEliminationOrder" begin
     problem = ColoringProblem(; structure=:symmetric, partition=:column)
-    algorithm = GreedyColoringAlgorithm(
-        PerfectEliminationOrder(); decompression=:substitution
+    direct_algo = GreedyColoringAlgorithm(PerfectEliminationOrder(); decompression=:direct)
+    substitution_algo = GreedyColoringAlgorithm(
+        PerfectEliminationOrder(CliqueTrees.LexBFS()); decompression=:substitution
     )
 
     # band graphs
@@ -126,7 +127,8 @@ end;
         matrix = permute!(sparse(Symmetric(brand(n, n, m, 0), :L)), perm, perm)
         π = vertices(AdjacencyGraph(matrix), PerfectEliminationOrder())
         @test isperm(π)
-        @test ncolors(coloring(matrix, problem, algorithm)) == m + 1
+        @test ncolors(coloring(matrix, problem, direct_algo)) == 2m + 1
+        @test ncolors(coloring(matrix, problem, substitution_algo)) == m + 1
     end
 
     # random graphs