Add more Graphs.jl wrappers, such as mincut

Author: mtfishman

Project.toml

@@ -7,13 +7,21 @@ version = "0.1.5"
 AbstractTrees = "1520ce14-60c1-5f80-bbc7-55ef81b5835c"
 Dictionaries = "85a47980-9c8c-11e8-2b9f-f7ca1fa99fb4"
 Graphs = "86223c79-3864-5bf0-83f7-82e725a168b6"
+GraphsFlows = "06909019-6f44-4949-96fc-b9d9aaa02889"
+LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 SimpleTraits = "699a6c99-e7fa-54fc-8d76-47d257e15c1d"
+SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
+SplitApplyCombine = "03a91e81-4c3e-53e1-a0a4-9c0c8f19dd66"
+SymRCM = "286e6d88-80af-4590-acc9-0001b223b9bd"
 
 [compat]
 AbstractTrees = "0.3, 0.4"
 Dictionaries = "0.3"
 Graphs = "1"
+GraphsFlows = "0.1.1"
 SimpleTraits = "0.9"
+SplitApplyCombine = "1.2.2"
+SymRCM = "0.2.1"
 julia = "1.7"
 
 [extras]

examples/boundary.jl

@@ -0,0 +1,19 @@
+using NamedGraphs
+using Graphs
+
+g = named_grid((5, 5))
+subgraph_vertices = [
+  (2, 2),
+  (2, 3),
+  (2, 4),
+  (3, 2),
+  (3, 3),
+  (3, 4),
+  (4, 2),
+  (4, 3),
+  (4, 4),
+]
+vs = @show boundary_vertices(g, subgraph_vertices)
+vs = @show inner_boundary_vertices(g, subgraph_vertices)
+vs = @show outer_boundary_vertices(g, subgraph_vertices)
+es = @show boundary_edges(g, subgraph_vertices)

examples/mincut.jl

@@ -0,0 +1,21 @@
+using NamedGraphs
+using GraphsFlows
+
+g = NamedGraph(path_graph(4), ["A", "B", "C", "D"])
+
+part1, part2 = mincut_partitions(g)
+@show part1, part2
+
+part1, part2 = mincut_partitions(g, "A", "D")
+@show part1, part2
+
+weights = Dict{Any,Float64}()
+weights["A", "B"] = 3.0
+weights["B", "C"] = 2.0
+weights["C", "D"] = 3.0
+
+part1, part2 = mincut_partitions(g, weights)
+@show part1, part2
+
+part1, part2 = mincut_partitions(g, "A", "D", weights)
+@show part1, part2

src/Graphs/abstractgraph.jl

@@ -23,6 +23,18 @@ end
   return digraph
 end
 
+@traitfn function directed_graph(graph::AbstractSimpleGraph::(!IsDirected))
+  digraph = directed_graph(typeof(graph))()
+  for v in vertices(graph)
+    add_vertex!(digraph)
+  end
+  for e in edges(graph)
+    add_edge!(digraph, e)
+    add_edge!(digraph, reverse(e))
+  end
+  return digraph
+end
+
 @traitfn undirected_graph(graph::::(!IsDirected)) = graph
 
 # TODO: Handle metadata in a generic way
@@ -53,6 +65,22 @@ function rename_vertices(g::AbstractGraph, name_map)
   return rename_vertices(v -> name_map[v], g)
 end
 
+function permute_vertices(graph::AbstractGraph, permutation::Vector)
+  return subgraph(graph, vertices(graph)[permutation])
+end
+
+# Uniform interface for `outneighbors`, `inneighbors`, and `all_neighbors`
+function _neighbors(graph::AbstractGraph, vertex; dir=:out)
+  if dir == :out
+    return outneighbors(graph, vertex)
+  elseif dir == :in
+    return inneighbors(graph, vertex)
+  elseif dir == :both
+    return all_neighbors(graph, vertex)
+  end
+  return error("`_neighbors(graph::AbstractGraph, vertex; dir)` with `dir = $(dir) not implemented. Use either `dir = :out`, `dir = :in`, or `dir = :both`.")
+end
+
 # Returns just the edges of a directed graph,
 # but both edge directions of an undirected graph.
 # TODO: Move to NamedGraphs.jl
@@ -162,10 +190,13 @@ function in_incident_edges(graph::AbstractGraph, vertex)
   ]
 end
 
+# TODO: Only return one set of `:out` edges for undirected graphs if `dir=:both`.
 function all_incident_edges(graph::AbstractGraph, vertex)
   return out_incident_edges(graph, vertex) ∪ in_incident_edges(graph, vertex)
 end
 
+# TODO: Same as `edges(subgraph(graph, [vertex; neighbors(graph, vertex)]))`.
+# TODO: Only return one set of `:out` edges for undirected graphs if `dir=:both`.
 """
     incident_edges(graph::AbstractGraph, vertex; dir=:out)
 
@@ -221,11 +252,13 @@ end
 end
 
 # Paths for undirected tree-like graphs
+# TODO: Use `a_star`.
 @traitfn function vertex_path(graph::::(!IsDirected), s, t)
   dfs_tree_graph = dfs_tree(graph, t)
   return vertex_path(dfs_tree_graph, s, t)
 end
 
+# TODO: Use `a_star`.
 @traitfn function edge_path(graph::::(!IsDirected), s, t)
   dfs_tree_graph = dfs_tree(graph, t)
   return edge_path(dfs_tree_graph, s, t)
@@ -295,7 +328,12 @@ end
 end
 
 # Paths for directed tree-like graphs
+# TODO: Use `a_star`, make specialized versions:
+# `vertex_path(graph::::IsTree, ...)`
+# or
+# `tree_vertex_path(graph, ...)`
 @traitfn function vertex_path(graph::::IsDirected, s, t)
+  # @assert is_tree(graph)
   vertices = eltype(graph)[s]
   while vertices[end] != t
     parent = parent_vertex(graph, vertices[end])
@@ -305,9 +343,22 @@ end
   return vertices
 end
 
+# TODO: Use `a_star`, make specialized versions:
+# `vertex_path(graph::::IsTree, ...)`
+# or
+# `tree_vertex_path(graph, ...)`
 @traitfn function edge_path(graph::::IsDirected, s, t)
+  # @assert is_tree(graph)
   vertices = vertex_path(graph, s, t)
   isnothing(vertices) && return nothing
   pop!(vertices)
   return [edgetype(graph)(vertex, parent_vertex(graph, vertex)) for vertex in vertices]
 end
+
+function mincut_partitions(
+  graph::AbstractGraph,
+  distmx=weights(graph),
+)
+  parts = groupfind(first(mincut(graph, distmx)))
+  return parts[1], parts[2]
+end

src/Graphs/boundary.jl

@@ -0,0 +1,54 @@
+# https://en.wikipedia.org/wiki/Boundary_(graph_theory)
+function boundary_edges(graph::AbstractGraph, subgraph_vertices; dir=:out)
+  E = edgetype(graph)
+  subgraph_vertices_set = Set(subgraph_vertices)
+  subgraph_complement = setdiff(Set(vertices(graph)), subgraph_vertices_set)
+  boundary_es = Vector{E}()
+  for subgraph_vertex in subgraph_vertices_set
+    for e in incident_edges(graph, subgraph_vertex; dir)
+      if src(e) ∈ subgraph_complement || dst(e) ∈ subgraph_complement
+        push!(boundary_es, e)
+      end
+    end
+  end
+  return boundary_es
+end
+
+# https://en.wikipedia.org/wiki/Boundary_(graph_theory)
+# See implementation of `Graphs.neighborhood_dists` as a reference.
+function inner_boundary_vertices(graph::AbstractGraph, subgraph_vertices; dir=:out)
+  V = vertextype(graph)
+  subgraph_vertices_set = Set(subgraph_vertices)
+  subgraph_complement = setdiff(Set(vertices(graph)), subgraph_vertices_set)
+  inner_boundary_vs = Vector{V}()
+  for subgraph_vertex in subgraph_vertices_set
+    for subgraph_vertex_neighbor in _neighbors(graph, subgraph_vertex; dir)
+      if subgraph_vertex_neighbor ∈ subgraph_complement
+        push!(inner_boundary_vs, subgraph_vertex)
+        break
+      end
+    end
+  end
+  return inner_boundary_vs
+end
+
+# https://en.wikipedia.org/wiki/Boundary_(graph_theory)
+# See implementation of `Graphs.neighborhood_dists` as a reference.
+function outer_boundary_vertices(graph::AbstractGraph, subgraph_vertices; dir=:out)
+  V = vertextype(graph)
+  subgraph_vertices_set = Set(subgraph_vertices)
+  subgraph_complement = setdiff(Set(vertices(graph)), subgraph_vertices_set)
+  outer_boundary_vs = Set{V}()
+  for subgraph_vertex in subgraph_vertices_set
+    for subgraph_vertex_neighbor in _neighbors(graph, subgraph_vertex; dir)
+      if subgraph_vertex_neighbor ∈ subgraph_complement
+        push!(outer_boundary_vs, subgraph_vertex_neighbor)
+      end
+    end
+  end
+  return [v for v in outer_boundary_vs]
+end
+
+function boundary_vertices(graph::AbstractGraph, subgraph_vertices; dir=:out)
+  return inner_boundary_vertices(graph, subgraph_vertices; dir)
+end

src/Graphs/shortestpaths.jl

@@ -0,0 +1,41 @@
+function dijkstra_parents(
+  graph::AbstractGraph,
+  vertex,
+  distmx=weights(graph)
+)
+  return dijkstra_shortest_paths(
+    graph,
+    [vertex],
+    distmx;
+    allpaths=false,
+    trackvertices=false).parents
+end
+
+function dijkstra_mst(
+  graph::AbstractGraph,
+  vertex,
+  distmx=weights(graph)
+) 
+  parents = dijkstra_shortest_paths(
+    graph,
+    [vertex],
+    distmx;
+    allpaths=false,
+    trackvertices=false).parents
+  mst = Vector{edgetype(graph)}()
+  for src in eachindex(parents)
+    dst = parents[src]
+    if src ≠ dst
+      push!(mst, edgetype(graph)(src, dst))
+    end
+  end
+  return mst
+end
+
+function dijkstra_tree(
+  graph::AbstractGraph,
+  vertex,
+  distmx=weights(graph),
+)
+  return tree(graph, dijkstra_parents(graph, vertex, distmx))
+end

src/Graphs/symrcm.jl

@@ -0,0 +1,8 @@
+# SymRCM.symrcm overload
+function symrcm(graph::AbstractGraph)
+  return symrcm(adjacency_matrix(graph))
+end
+
+function symrcm_permute(graph::AbstractGraph)
+  return permute_vertices(graph, symrcm(graph))
+end