Improve performance of algorithm ND.

Author: samuelsonric

ext/LaplaciansExt.jl

@@ -1,6 +1,7 @@
 module LaplaciansExt
 
 using CliqueTrees
+using CliqueTrees: simplegraph
 using Graphs
 using Laplacians
 using SparseArrays
@@ -9,7 +10,7 @@ function CliqueTrees.permutation(graph, alg::Spectral)
     return permutation(BipartiteGraph(graph), alg)
 end
 
-function CliqueTrees.permutation(graph::BipartiteGraph{V}, alg::Spectral) where {V}
+function CliqueTrees.permutation(graph::AbstractGraph, alg::Spectral)
     order = spectralorder(graph; tol = alg.tol)
     return order, invperm(order)
 end
@@ -19,10 +20,9 @@ end
 # Algorithm 1: Spectral Algorithm
 #
 # Compute the spectral ordering of a graph.
-function spectralorder(graph::BipartiteGraph{V}; tol::Float64 = 0.0) where {V}
+function spectralorder(graph::AbstractGraph{V}; tol::Float64 = 0.0) where {V}
     order = Vector{V}(undef, nv(graph))
-    matrix = SparseMatrixCSC{Float64}(graph)
-    fill!(nonzeros(fkeep!((i, j, v) -> i != j, matrix)), 1)
+    matrix = sparse(Float64, simplegraph(graph))
     value, vector = fiedler(matrix; tol)
     return sortperm!(order, reshape(vector, size(matrix, 2)))
 end

ext/MetisExt.jl

@@ -1,9 +1,11 @@
 module MetisExt
 
+using ArgCheck
 using CliqueTrees
-using CliqueTrees: simplegraph
+using CliqueTrees: Scalar, View, simplegraph
 using Graphs
-using Metis: Metis
+
+import Metis
 
 const INT = Metis.idx_t
 
@@ -100,12 +102,14 @@ function CliqueTrees.permutation(graph::AbstractGraph{V}, alg::METIS) where {V}
     return order, index
 end
 
-function CliqueTrees.separator(weights::AbstractVector, graph::BipartiteGraph{INT, INT}, alg::METISND)
-    return CliqueTrees.separator(trunc.(INT, weights), graph, alg)
+function CliqueTrees.separator!(sepsize::Scalar{INT}, part::Vector{INT}, weights::AbstractVector, graph::BipartiteGraph{INT, INT}, alg::METISND)
+    return CliqueTrees.separator!(sepsize, part, trunc.(INT, weights), graph, alg)
 end
 
-function CliqueTrees.separator(weights::Vector{INT}, graph::BipartiteGraph{INT, INT}, alg::METISND)
+function CliqueTrees.separator!(sepsize::Scalar{INT}, part::Vector{INT}, weights::Union{View{INT}, Vector{INT}}, graph::BipartiteGraph{INT, INT}, alg::METISND)
     m = ne(graph); n = nv(graph); nn = n + one(INT)
+    @argcheck n <= length(part)
+    @argcheck n <= length(weights)
 
     # construct options
     options = Vector{INT}(undef, Metis.METIS_NOPTIONS)
@@ -115,14 +119,11 @@ function CliqueTrees.separator(weights::Vector{INT}, graph::BipartiteGraph{INT,
     options[Metis.METIS_OPTION_UFACTOR + 1] = alg.ufactor
 
     # construct METIS graph
-    xadj = pointers(graph) .- one(INT)
-    adjncy = targets(graph) .- one(INT)
+    xadj = pointers(graph); xadj .-= one(INT)
+    adjncy = targets(graph); adjncy .-= one(INT)
     vwght = weights
 
     # construct separator
-    part = Vector{INT}(undef, n)
-    sepsize = fill(zero(INT), 1)
-
     Metis.@check Metis.METIS_ComputeVertexSeparator(
         Ref{INT}(n),
         xadj,
@@ -133,7 +134,9 @@ function CliqueTrees.separator(weights::Vector{INT}, graph::BipartiteGraph{INT,
         part,
     )
 
-    return part
+    xadj .+= one(INT)
+    adjncy .+= one(INT)
+    return
 end
 
 end

src/bipartite_graphs.jl

@@ -1,6 +1,6 @@
 # A simple bipartite graph (U, V, E). If U = V, then you can think of this as a directed graph.
 # This type implements the abstract graph interface.
-struct BipartiteGraph{V <: Signed, E <: Signed, Ptr <: AbstractVector{E}, Tgt <: AbstractVector{V}} <:
+struct BipartiteGraph{V <: Integer, E <: Integer, Ptr <: AbstractVector{E}, Tgt <: AbstractVector{V}} <:
     AbstractGraph{V}
     nov::V
     ptr::Ptr
@@ -322,6 +322,10 @@ function Base.reverse!(count::Vector{E}, result::BipartiteGraph{V, E}, graph::Ab
     return result
 end
 
+function simplegraph(::Type{V}, ::Type{E}, graph) where {V, E}
+    return simplegraph(V, E, BipartiteGraph(graph))
+end
+
 function simplegraph(::Type{V}, ::Type{E}, graph::AbstractGraph{VV}) where {V, E, VV}
     m = de(graph); n = nv(graph)
     simple = BipartiteGraph{V, E}(n, n, m)
@@ -344,10 +348,18 @@ function simplegraph(::Type{V}, ::Type{E}, graph::AbstractGraph{VV}) where {V, E
     return simple
 end
 
+function simplegraph(::Type{V}, graph) where {V}
+    return simplegraph(V, BipartiteGraph(graph))
+end
+
 function simplegraph(::Type{V}, graph::AbstractGraph) where {V}
     return simplegraph(V, etype(graph), graph)
 end
 
+function simplegraph(graph)
+    return simplegraph(BipartiteGraph(graph))
+end
+
 function simplegraph(graph::AbstractGraph{V}) where {V}
     return simplegraph(V, graph)
 end
@@ -393,7 +405,7 @@ function Base.copy!(dst::BipartiteGraph, src::BipartiteGraph)
     return dst
 end
 
-function Base.copy!(dst::BipartiteGraph{V, E, Ptr, OneTo{V}}, src::BipartiteGraph) where {V <: Signed, E <: Signed, Ptr <: AbstractVector{E}}
+function Base.copy!(dst::BipartiteGraph{V, E, Ptr, OneTo{V}}, src::BipartiteGraph) where {V <: Integer, E <: Integer, Ptr <: AbstractVector{E}}
     @argcheck nov(dst) == nov(src)
     @argcheck targets(dst) == targets(src)
     copy!(pointers(dst), pointers(src))

src/dissection_algorithms.jl

@@ -8,7 +8,7 @@ abstract type DissectionAlgorithm end
 """
     METISND <: DissectionAlgorithm
 
-Compute a vertex separator using METIS.
+Compute a vertex separator using `METIS_computeVertexSeparator`.
 """
 @kwdef struct METISND <: DissectionAlgorithm
     ufactor::Int = -1
@@ -23,12 +23,8 @@ end
 #     project(i) = 0 iff i ∈ W - B
 #     project(i) = 1 iff i ∈ B - W
 #     project(i) = 2 iff i ∈ W ∩ B
-function separator(weights::AbstractVector, graph::AbstractGraph, alg::DissectionAlgorithm)
-    throw(
-        ArgumentError(
-            "Algorithm $alg not implemented. You may need to load an additional package."
-        ),
-    )
+function separator!(sepsize::AbstractScalar, part::AbstractVector, weights::AbstractVector, graph::AbstractGraph, alg::DissectionAlgorithm)
+    throw(ArgumentError("Algorithm $alg not implemented. You may need to load an additional package."))
 end
 
 function Base.show(io::IO, ::MIME"text/plain", alg::METISND)