Add function treefill. Also,

  - improve performance of algorithm `ND`
  - expand type union `PermutationOrAlgorithm`
  - improve code coverage

Author: samuelsonric

src/CliqueTrees.jl

@@ -66,6 +66,7 @@ export BFS,
     SafeSeparators,
     ConnectedComponents,
     BestWidth,
+    BestFill,
     permutation,
     mcs
 
@@ -82,7 +83,7 @@ export SupernodeTree, supernodetree, residuals
 export Clique, separator, residual
 
 # Clique Trees
-export CliqueTree, cliquetree, treewidth, separators, relatives
+export CliqueTree, cliquetree, treewidth, treefill, separators, relatives
 
 # Abstract Trees
 export firstchildindex, rootindices, ancestorindices

src/Utilities.jl/src/Utilities.jl

@@ -6,7 +6,7 @@ using Base.Order
 using Graphs
 
 # arithmetic
-export tolerance, twice, half, two, three, four, ispositive, isnegative, istwo, isthree
+export tolerance, twice, half, two, three, four, ispositive, isnegative, istwo, isthree, isfour
 
 # graphs
 export eltypedegree, de
@@ -71,6 +71,10 @@ function isnegative(i::I) where {I}
     return i < zero(I)
 end
 
+function isfour(i::I) where {I}
+    return i == four(I)
+end
+
 function isthree(i::I) where {I}
     return i == three(I)
 end
@@ -174,13 +178,33 @@ end
 end
 
 function printiterator(io::IO, iterator::T) where {T}
+    return printiterator(io, iterator, Base.IteratorSize(T))
+end
+
+function printiterator(io::IO, iterator::T, ::Any) where {T}
     print(io, "$T:")
+    printelements(io, iterator)
+    return
+end
+
+function printiterator(io::IO, iterator::T, ::Base.HasLength) where {T}
+    n = length(iterator)
+    print(io, "$n-element $T:")
+    printelements(io, iterator)
+    return
+end
+
+function printelements(io::IO, iterator)
+    count = 0
+
+    for v in iterator
+        count += 1
 
-    for (i, v) in enumerate(take(iterator, MAX_ITEMS_PRINTED + 1))
-        if i <= MAX_ITEMS_PRINTED
+        if count <= MAX_ITEMS_PRINTED
             print(io, "\n $v")
         else
             print(io, "\n ⋮")
+            break
         end
     end
 

src/ambiguities.jl

@@ -1,9 +1,16 @@
+# ---------- #
+# lowerbound #
+# ---------- #
+lowerbound(weights::AbstractVector, ::Number) = error()
+lowerbound(weights::AbstractVector, ::MMW) = error()
+
 # ----------- #
 # permutation #
 # ----------- #
 
 permutation(weights::AbstractVector, alg::EliminationAlgorithm) = error()
 permutation(weights::AbstractVector, alg::AbstractVector) = error()
+permutation(weights::AbstractVector, alg::Tuple{AbstractVector, AbstractVector}) = error()
 permutation(weights::AbstractVector, alg::BFS) = error()
 permutation(weights::AbstractVector, alg::MCS) = error()
 permutation(weights::AbstractVector, alg::LexBFS) = error()
@@ -27,6 +34,7 @@ permutation(weights::AbstractVector, alg::SafeRules) = error()
 permutation(weights::AbstractVector, alg::SafeSeparators) = error()
 permutation(weights::AbstractVector, alg::ConnectedComponents) = error()
 permutation(weights::AbstractVector, alg::BestWidth) = error()
+permutation(weights::AbstractVector, alg::BestFill) = error()
 
 # --------------- #
 # eliminationtree #
@@ -39,3 +47,9 @@ eliminationtree(weights::AbstractVector, alg::PermutationOrAlgorithm) = error()
 # --------- #
 
 treewidth(weights::AbstractVector, alg::PermutationOrAlgorithm) = error()
+
+# -------- #
+# treefill #
+# -------- #
+
+treefill(weights::AbstractVector, alg::PermutationOrAlgorithm) = error()

src/bipartite_edge_iter.jl

@@ -2,17 +2,8 @@ struct BipartiteEdgeIter{V, E, Ptr, Tgt} <: AbstractEdgeIter
     graph::BipartiteGraph{V, E, Ptr, Tgt}
 end
 
-function Base.show(io::IO, iter::I) where {I <: BipartiteEdgeIter}
-    n = length(iter)
-    println(io, "$n-element $I:")
-
-    for (i, edge) in enumerate(take(iter, MAX_ITEMS_PRINTED + 1))
-        if i <= MAX_ITEMS_PRINTED
-            println(io, " $edge")
-        else
-            println(io, " ⋮")
-        end
-    end
+function Base.show(io::IO, iter::BipartiteEdgeIter)
+    printiterator(io, iter)
     return
 end
 
@@ -32,22 +23,30 @@ end
 # Iteration Interface #
 #######################
 
-function Base.iterate(
-        iter::BipartiteEdgeIter{V, E}, (i, p)::Tuple{V, E} = (one(V), one(E))
-    ) where {V, E}
-    return if p <= length(iter)
-        edge = SimpleEdge{V}(i, targets(iter.graph)[p])
+function Base.iterate(iter::BipartiteEdgeIter{V, E}, (i, p)::Tuple{V, E} = (one(V), one(E))) where {V, E}
+    graph = iter.graph; ii = i + one(V); pp = p + one(E)
+    result = nothing
 
-        j = i + one(V)
-        q = p + one(E)
-        state = q < pointers(iter.graph)[j] ? (i, q) : (j, q)
+    if p <= ne(graph)
+        @inbounds j = targets(graph)[p]
+        @inbounds qq = pointers(graph)[ii]
+        edge = SimpleEdge{V}(i, j)
 
-        edge, state
+        if pp < qq
+            state = (i, pp)
+        else
+            state = (ii, pp)
+        end
+
+        result = (edge, state)
     end
+
+    return result
 end
 
 function Base.length(iter::BipartiteEdgeIter)
-    return ne(iter.graph)
+    m::Int = ne(iter.graph)
+    return m
 end
 
 function Base.eltype(::Type{<:BipartiteEdgeIter{V}}) where {V}

src/bipartite_graphs.jl

@@ -229,12 +229,20 @@ function sympermute!(
         index::AbstractVector,
         order::Ordering,
     ) where {V, E}
-    # validate arguments
     @argcheck vertices(graph) == vertices(result)
     @argcheck vertices(graph) == eachindex(index)
+    count = Vector{E}(undef, nv(graph) + one(V))
+    return sympermute!(count, result, graph, index, order)
+end
 
+function sympermute!(
+        count::Vector{E},
+        result::BipartiteGraph{V, E},
+        graph::AbstractGraph,
+        index::AbstractVector,
+        order::Ordering,
+    ) where {V, E}
     # compute column counts
-    count = Vector{E}(undef, nv(graph) + one(V))
     count[one(V)] = one(E)
     count[two(V):(nv(graph) + one(V))] .= zero(E)
 
@@ -286,9 +294,12 @@ function Base.reverse!(result::BipartiteGraph{V, E}, graph::AbstractGraph{V}) wh
     @argcheck nv(graph) == nov(result)
     @argcheck ne(graph) == ne(result)
     @argcheck nov(graph) == nv(result)
+    count = Vector{E}(undef, nov(graph) + one(V))
+    return reverse!(count, result, graph)
+end
 
+function Base.reverse!(count::Vector{E}, result::BipartiteGraph{V, E}, graph::AbstractGraph{V}) where {V, E}
     # compute column counts
-    count = Vector{E}(undef, nov(graph) + one(V))
     count[one(V)] = one(E)
     count[two(V):(nov(graph) + one(V))] .= zero(E)
 
@@ -444,12 +455,13 @@ function Graphs.vertices(graph::BipartiteGraph{V}) where {V}
     return oneto(nv(graph))
 end
 
-@propagate_inbounds function Graphs.outneighbors(
-        graph::BipartiteGraph{<:Any, E}, i::Integer
-    ) where {E}
+@propagate_inbounds function Graphs.outneighbors(graph::BipartiteGraph{<:Any, E}, i::I) where {E, I <: Integer}
+    ii = i + one(I)
     @boundscheck checkbounds(pointers(graph), i)
-    @boundscheck checkbounds(pointers(graph), i + 1)
-    return @inbounds @view targets(graph)[pointers(graph)[i]:(pointers(graph)[i + 1] - one(E))]
+    @boundscheck checkbounds(pointers(graph), ii)
+    @inbounds p = pointers(graph)[i]
+    @inbounds pp = pointers(graph)[ii]
+    return @view targets(graph)[p:(pp - one(E))]
 end
 
 # slow
@@ -459,23 +471,24 @@ function Graphs.inneighbors(graph::BipartiteGraph, i::Integer)
     end
 end
 
-@propagate_inbounds function Graphs.outdegree(
-        graph::BipartiteGraph{V}, i::Integer
-    ) where {V}
+@propagate_inbounds function Graphs.outdegree(graph::BipartiteGraph, i::I) where {I <: Integer}
+    ii = i + one(I)
     @boundscheck checkbounds(pointers(graph), i)
-    @boundscheck checkbounds(pointers(graph), i + 1)
-    @inbounds n::V = pointers(graph)[i + 1] - pointers(graph)[i]
+    @boundscheck checkbounds(pointers(graph), ii)
+    @inbounds p = pointers(graph)[i]
+    @inbounds pp = pointers(graph)[ii]
+    n::Int = pp - p
     return n
 end
 
 # slow
 function Graphs.indegree(graph::BipartiteGraph{V}, i::Integer) where {V}
-    n::V = sum(j -> has_edge(graph, j, i), vertices(graph))
+    n::Int = sum(j -> has_edge(graph, j, i), vertices(graph))
     return n
 end
 
-function Graphs.Δout(graph::BipartiteGraph{V}) where {V}
-    return maximum(vertices(graph); init = zero(V)) do i
+function Graphs.Δout(graph::BipartiteGraph)
+    return maximum(vertices(graph); init = 0) do i
         outdegree(graph, i)
     end
 end

src/chordal_graphs.jl

@@ -29,17 +29,18 @@ end
 function isperfect(
         graph::AbstractGraph{V}, order::AbstractVector{V}, index::AbstractVector{V}
     ) where {V}
+    n = nv(graph)
+
     # validate arguments
     @argcheck vertices(graph) == eachindex(index)
     @argcheck vertices(graph) == eachindex(order)
 
     # run algorithm
-    f = Vector{V}(undef, nv(graph))
-    findex = Vector{V}(undef, nv(graph))
+    f = Vector{V}(undef, n)
+    findex = Vector{V}(undef, n)
 
-    for (i, w) in enumerate(order)
-        f[w] = w
-        findex[w] = i
+    for i in oneto(n)
+        w = order[i]; f[w] = w; findex[w] = i
 
         for v in neighbors(graph, w)
             if index[v] < i