graph_matching 0.0.1

data/lib/graph_matching/graph/weighted_graph.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require_relative 'weighted'
+require_relative '../algorithm/mwm_general'
+
+module GraphMatching
+  module Graph
+    # A graph whose edges have weights.  See `Weighted`.
+    class WeightedGraph < Graph
+      include Weighted
+
+      def maximum_weighted_matching(max_cardinality)
+        Algorithm::MWMGeneral.new(self).match(max_cardinality)
+      end
+    end
+  end
+end

data/lib/graph_matching/integer_vertexes.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module GraphMatching
+  # Converts the vertices of a graph to integers.  Many graph
+  # matching algorithms require integer vertexes.
+  module IntegerVertexes
+    # Converts the vertices of `graph` to positive nonzero integers.
+    # For example, given a graph (a=b), returns a new graph (1=2).
+    # It also returns a legend, which maps the integers to the
+    # original vertexes.
+    #
+    def self.to_integers(graph)
+      fail ArgumentError unless graph.is_a?(RGL::MutableGraph)
+      legend = {}
+      reverse_legend = {}
+      new_graph = graph.class.new
+      graph.vertices.each_with_index do |vertex, ix|
+        legend[ix + 1] = vertex
+        reverse_legend[vertex] = ix + 1
+      end
+      graph.edges.each do |edge|
+        source = reverse_legend[edge.source]
+        target = reverse_legend[edge.target]
+        new_graph.add_edge(source, target)
+      end
+      return new_graph, legend
+    end
+  end
+end

data/lib/graph_matching/matching.rb

@@ -0,0 +1,120 @@
+# encoding: utf-8
+
+module GraphMatching
+  # > In .. graph theory, a matching .. in a graph is a set of
+  # > edges without common vertices.
+  # > https://en.wikipedia.org/wiki/Matching_%28graph_theory%29
+  class Matching
+    # Gabow (1976) uses a simple array to store his matching.  It
+    # has one element for each vertex in the graph.  The value of
+    # each element is either the number of another vertex (Gabow
+    # uses sequential integers for vertex numbering) or a zero if
+    # unmatched.  So, `.gabow` returns a `Matching` initialized
+    # from such an array.
+    def self.gabow(mate)
+      m = new
+      mate.each_with_index do |n1, ix|
+        next if n1.nil? || n1 == 0
+        n2 = mate[n1]
+        if n2 == ix
+          m.add([n1, n2])
+        end
+      end
+      m
+    end
+
+    # Van Rantwijk's matching is constructed from two arrays,
+    # `mate` and `endpoint`.
+    #
+    # - `endpoint` is an array where each edge is represented by
+    #   two consecutive elements, which are vertex numbers.
+    # - `mate` is an array whose indexes are vertex numbers, and
+    #   whose values are `endpoint` indexes, or `nil` if the vertex
+    #   is single (unmatched).
+    #
+    # A matched vertex `v`'s partner is `endpoint[mate[v]]`.
+    #
+    def self.from_endpoints(endpoint, mate)
+      m = Matching.new
+      mate.each do |p|
+        m.add([endpoint[p], endpoint[p ^ 1]]) unless p.nil?
+      end
+      m
+    end
+
+    def self.[](*edges)
+      new.tap { |m| edges.each { |e| m.add(e) } }
+    end
+
+    def initialize
+      @ary = []
+    end
+
+    def [](i)
+      @ary[i]
+    end
+
+    def add(e)
+      i, j = e
+      @ary[i] = j
+      @ary[j] = i
+    end
+
+    def delete(e)
+      i, j = e
+      @ary[i] = nil
+      @ary[j] = nil
+    end
+
+    # `edges` returns an array of undirected edges, represented as
+    # two-element arrays.
+    def edges
+      undirected_edges.map(&:to_a)
+    end
+
+    def empty?
+      @ary.all?(&:nil?)
+    end
+
+    def edge?(e)
+      i, j = e
+      !@ary[i].nil? && @ary[i] == j && @ary[j] == i
+    end
+
+    def vertex?(v)
+      @ary.include?(v)
+    end
+
+    # `size` returns number of edges
+    def size
+      @ary.compact.size / 2
+    end
+
+    def to_a
+      result = []
+      skip = []
+      @ary.each_with_index { |e, i|
+        unless e.nil? || skip.include?(i)
+          result << [i, e]
+          skip << e
+        end
+      }
+      result
+    end
+
+    # Given a `Weighted` graph `g`, returns the sum of edge weights.
+    def weight(g)
+      edges.map { |e| g.w(e) }.reduce(0, :+)
+    end
+
+    def undirected_edges
+      @ary.each_with_index.inject(Set.new) { |set, (el, ix)|
+        el.nil? ? set : set.add(RGL::Edge::UnDirectedEdge.new(el, ix))
+      }
+    end
+
+    def vertexes
+      @ary.compact
+    end
+  end
+end

data/lib/graph_matching/ordered_set.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+module GraphMatching
+  # An `OrderedSet` acts like a `Set`, but preserves insertion order.
+  # Internally, a `Hash` is used because, as of Ruby 1.9, it
+  # preserves insertion order.  The Set library happens to be built
+  # upon a Hash currently but this might change in the future.
+  class OrderedSet
+    include Enumerable
+
+    # `.[]` returns a new ordered set containing the given objects.
+    # This mimics the signature of `Set.[]` and `Array.[]`.
+    def self.[](*args)
+      new.merge(args)
+    end
+
+    def initialize
+      @hash = {}
+    end
+
+    # `add` `o` unless it already exists, preserving inserting order.
+    # This mimics the signature of `Set#add`.  See alias `#enq`.
+    def add(o)
+      @hash[o] = true
+    end
+    alias_method :enq, :add
+
+    def deq
+      @hash.keys.first.tap do |k| @hash.delete(k) end
+    end
+
+    def each
+      @hash.each do |k, _v| yield k end
+    end
+
+    def empty?
+      @hash.empty?
+    end
+
+    # `merge` the elements of the given enumerable object to the set
+    # and returns self.  This mimics the signature of `Set#merge`.
+    def merge(enum)
+      enum.each do |e| add(e) end
+      self
+    end
+
+    # Removes the last element and returns it, or nil if empty.
+    # This mimics `Array#pop`.  See related `#deq`.
+    def pop
+      @hash.keys.last.tap do |k| @hash.delete(k) end
+    end
+
+    # `push` appends the given object(s) and returns self.  This
+    # mimics the signature of `Array#push`.
+    def push(*args)
+      merge(args)
+    end
+  end
+end

data/lib/graph_matching/version.rb

@@ -0,0 +1,6 @@
+# encoding: utf-8
+
+# no-doc
+module GraphMatching
+  VERSION = "0.0.1"
+end

data/lib/graph_matching/visualize.rb

@@ -0,0 +1,93 @@
+# encoding: utf-8
+
+require 'open3'
+require 'rgl/rdot'
+
+module GraphMatching
+  # Renders `GraphMatching::Graph` objects using `graphviz`.
+  class Visualize
+    TMP_DIR = '/tmp/graph_matching'
+    USR_BIN_ENV = '/usr/bin/env'
+
+    attr_reader :graph
+
+    def initialize(graph)
+      @graph = graph
+    end
+
+    # `dot` returns a string representing the graph, in .dot format.
+    # http://www.graphviz.org/content/dot-language
+    def dot
+      RGL::DOT::Graph.new('elements' => dot_edges).to_s
+    end
+
+    # `png` writes a ".png" file with graphviz and opens it
+    def png(base_filename)
+      check_that_dot_is_installed
+      mk_tmp_dir
+      abs_path = "#{TMP_DIR}/#{base_filename}.png"
+      write_png(abs_path)
+      system "open #{abs_path}"
+    end
+
+    private
+
+    def check_that_dot_is_installed
+      return if dot_installed?
+      $stderr.puts "Executable not found: dot"
+      $stderr.puts "Please install graphviz"
+      exit(1)
+    end
+
+    def dot_edge(u, v, label)
+      RGL::DOT::Edge.new(
+        { 'from' => u, 'to' => v, 'label' => label },
+        ['label']
+      )
+    end
+
+    def dot_edges
+      graph.edges.map { |e| dot_edge(e.source, e.target, dot_edge_label(e)) }
+    end
+
+    def dot_edge_label(edge)
+      graph.is_a?(GraphMatching::Graph::Weighted) ? graph.w([*edge]) : nil
+    end
+
+    def assert_usr_bin_env_exists
+      return if File.exist?(USR_BIN_ENV)
+      $stderr.puts "File not found: #{USR_BIN_ENV}"
+      exit(1)
+    end
+
+    # `dot_installed?` returns true if `dot` is installed, otherwise
+    # false.  Note that `system` returns true if the command gives
+    # zero exit status, false for non-zero exit status.
+    def dot_installed?
+      assert_usr_bin_env_exists
+      system "#{USR_BIN_ENV} which dot > /dev/null"
+    end
+
+    def mk_tmp_dir
+      Dir.mkdir(TMP_DIR) unless Dir.exist?(TMP_DIR)
+    end
+
+    def safe_vertex(v)
+      if v.is_a?(Integer)
+        v
+      elsif v.respond_to?(:to_dot)
+        v.to_dot
+      else
+        v.to_s.gsub(/[^a-zA-Z0-9]/, '')
+      end
+    end
+
+    def write_png(abs_path)
+      _so, se, st = Open3.capture3("dot -T png > #{abs_path}", stdin_data: dot)
+      return if st.success?
+      $stderr.puts "Failed to generate .png"
+      $stderr.puts se
+      exit(1)
+    end
+  end
+end

data/profile/mcm_bipartite/compare.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+
+BENCHMARK_DIR='benchmark/mcm_bipartite/complete_bigraphs'
+
+if [ ! -d "$BENCHMARK_DIR" ]; then
+  echo "Directory not found: $BENCHMARK_DIR" 1>&2
+  exit 1
+fi
+
+echo "Benchmarking .."
+ruby -I lib "$BENCHMARK_DIR/benchmark.rb" > "$BENCHMARK_DIR/time2.data"
+
+echo "Plotting .."
+gnuplot "$BENCHMARK_DIR/compare.gnuplot"
+open "$BENCHMARK_DIR/plot_compare.png"

data/profile/mcm_bipartite/publish.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+
+BENCHMARK_DIR='benchmark/mcm_bipartite/complete_bigraphs'
+
+if [ ! -d "$BENCHMARK_DIR" ]; then
+  echo "Directory not found: $BENCHMARK_DIR" 1>&2
+  exit 1
+fi
+
+rm "$BENCHMARK_DIR/plot_compare.png"
+mv "$BENCHMARK_DIR/time2.data" "$BENCHMARK_DIR/time.data"
+gnuplot "$BENCHMARK_DIR/plot.gnuplot"

data/profile/mwm_general/compare.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+
+BENCHMARK_DIR='benchmark/mwm_general/complete_graphs'
+
+if [ ! -d "$BENCHMARK_DIR" ]; then
+  echo "Directory not found: $BENCHMARK_DIR" 1>&2
+  exit 1
+fi
+
+echo "Benchmarking .."
+ruby -I lib "$BENCHMARK_DIR/benchmark.rb" > "$BENCHMARK_DIR/time2.data"
+
+echo "Plotting .."
+gnuplot "$BENCHMARK_DIR/compare.gnuplot"
+open "$BENCHMARK_DIR/plot_compare.png"

data/profile/mwm_general/profile.rb

@@ -0,0 +1,28 @@
+# No shebang here.  Run with:
+#
+# ruby -I lib profile/mwm_general/profile.rb
+
+require 'graph_matching'
+require 'ruby-prof'
+
+def complete_graph(n)
+  g = GraphMatching::Graph::WeightedGraph.new
+  n_edges = (1 .. n - 1).reduce(:+)
+  0.upto(n - 2) do |i|
+    (i + 1).upto(n - 1) do |j|
+      g.add_edge(i, j)
+      g.set_w([i, j], rand(n_edges))
+    end
+  end
+  g
+end
+
+g = complete_graph(100)
+GC.disable
+RubyProf.start
+g.maximum_weighted_matching(true)
+result = RubyProf.stop
+GC.enable
+
+printer = RubyProf::FlatPrinter.new(result)
+printer.print(STDOUT)

data/profile/mwm_general/publish.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+
+BENCHMARK_DIR='benchmark/mwm_general/complete_graphs'
+
+if [ ! -d "$BENCHMARK_DIR" ]; then
+  echo "Directory not found: $BENCHMARK_DIR" 1>&2
+  exit 1
+fi
+
+rm "$BENCHMARK_DIR/plot_compare.png"
+mv "$BENCHMARK_DIR/time2.data" "$BENCHMARK_DIR/time.data"
+gnuplot "$BENCHMARK_DIR/plot.gnuplot"

data/research/examples/unweighted_general/1.txt

@@ -0,0 +1,86 @@
+Stage 1
+
+          5 -- 7
+        / ||   ||
+   1 = 3  ||   o
+  /     \ ||
+r        6
+  \     /
+   2 = 4
+  /
+a
+
+S = [ 1 by r, 2 by r, 5 by 3, 6 by 3 ]
+T = [ 3 by 1, 4 by 1 ]
+
+Stage 2
+
+   1 = B -- 7
+  /    |    ||
+r      |    o
+  \    |
+   2 = 4
+  /
+a
+
+S = [ 1 by r, 2 by r, 5 by 3, 6 by 3 ]
+T = [ 3 by 1, 4 by 1 ]
+
+Stage 3
+
+  B -- 7
+ /     ||
+a      o
+
+Find augmenting path from r, *through B* to a
+
+1. AP = (a,B)
+1. expand B
+
+   1 = B -- 7
+  /    |    ||
+r      |    o
+  \    |
+   2 = 4
+  /
+a
+
+1. Kusner says: "propagating the augmenting path through the expansion steps"
+1. AP = (a,2), etc.. but how to find "etc"?  We know we want an
+   alternating path, so starting at 2, find a matched edge.
+1. AP = a2, 24
+1. AP = a2, 24, 4B
+1. B is a blossom.  Expand it.
+
+          5 -- 7
+        / ||   ||
+   1 = 3  ||   o
+  /     \ ||
+r        6
+  \     /
+   2 = 4
+  /
+a
+
+1. AP = a2, 24, 46
+1. AP = a2, 24, 46, 65
+1. Should we follow (5,3) or (5,7), or both?
+1. Following (5,7) doesn't reach r, and if we follow it,
+   either depth-first or breadth-first, we'll learn that.
+1. AP = a2, 24, 46, 65, 53
+1. AP = a2, 24, 46, 65, 53, 31
+1. AP = a2, 24, 46, 65, 53, 31, 1r
+1. Augmenting path: a, 2, 4, 6, 5, 3, 1, r
+
+          5 -- 7
+        //|   ||
+   1 - 3  |   o
+  //     \|
+r        6
+  \     //
+   2 - 4
+  //
+a
+
+1. size of matching = 5.  Decide is maximum cardinality
+   matching.  (How?)