graph_matching 0.0.1

data/spec/graph_matching/algorithm/matching_algorithm_spec.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe GraphMatching::Algorithm::MatchingAlgorithm do
+  let(:algorithm) { described_class.new(double) }
+
+  describe '#assert' do
+    it 'returns an Assertion' do
+      expect(algorithm.assert('banana')).to \
+        be_a(GraphMatching::Assertion)
+    end
+  end
+end

data/spec/graph_matching/algorithm/mcm_bipartite_spec.rb

@@ -0,0 +1,98 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe GraphMatching::Algorithm::MCMBipartite do
+  let(:g) { GraphMatching::Graph::Bigraph.new }
+
+  describe '.new' do
+    it 'requires a Bigraph' do
+      expect { described_class.new("banana") }.to raise_error(TypeError)
+    end
+  end
+
+  describe '#augment' do
+    it 'augments the matching' do
+      mcm = described_class.new(g)
+      m = [nil, nil, 3, 2]
+      m = mcm.send(:augment, m, [1, 2, 3, 4])
+      expect(m).to eq([nil, 2, 1, 4, 3])
+      m = mcm.send(:augment, m, [1, 2, 4, 5, 6, 7])
+      expect(m).to eq([nil, 2, 1, nil, 5, 4, 7, 6])
+    end
+  end
+
+  describe '#match' do
+    context 'empty graph' do
+      it 'returns empty set' do
+        m = described_class.new(g).match
+        expect(m).to be_empty
+      end
+    end
+
+    context 'single vertex' do
+      it 'returns empty set' do
+        g.add_vertex(0)
+        expect(described_class.new(g).match).to be_empty
+      end
+    end
+
+    context 'single edge' do
+      it 'returns set with one edge' do
+        e = [1, 2]
+        g.add_edge(*e)
+        m = described_class.new(g).match
+        expect(m.size).to eq(1)
+        expect(m.edge?(e)).to eq(true)
+      end
+    end
+
+    context 'complete bigraph with four vertexes' do
+      let(:edges) { [[1, 3], [1, 4], [2, 3], [2, 4]] }
+
+      it 'returns one of the two correct results' do
+        edges.each { |e| g.add_edge(*e) }
+        m = described_class.new(g).match
+        expect(m.size).to eq(2)
+        outcomes = [
+          RGL::AdjacencyGraph[1, 3, 2, 4],
+          RGL::AdjacencyGraph[1, 4, 2, 3]
+        ]
+        reconstructed = RGL::AdjacencyGraph.new
+        m.to_a.each { |edge| reconstructed.add_edge(*edge) }
+        expect(outcomes).to include(reconstructed)
+      end
+    end
+
+    # The following example is by Derrick Stolee
+    # http://www.youtube.com/watch?v=C9c8zEZXboA
+    context 'incomplete bigraph with twelve vertexes' do
+      let(:edges) {
+        [
+          [1, 8],
+          [2, 9], [2, 10],
+          [3, 7], [3, 9], [3, 12],
+          [4, 8], [4, 10],
+          [5, 10], [5, 11],
+          [6, 11]
+        ]
+      }
+
+      it 'returns one of the five correct results' do
+        edges.each { |e| g.add_edge(*e) }
+        m = described_class.new(g).match
+        expect(m.size).to eq(5)
+        outcomes = [
+          RGL::AdjacencyGraph[1, 8, 2, 9, 3, 7, 5, 10, 6, 11],
+          RGL::AdjacencyGraph[1, 8, 2, 9, 3, 7, 4, 10, 5, 11],
+          RGL::AdjacencyGraph[1, 8, 2, 9, 3, 7, 4, 10, 6, 11],
+          RGL::AdjacencyGraph[1, 8, 2, 9, 3, 12, 4, 10, 5, 11],
+          RGL::AdjacencyGraph[2, 9, 3, 7, 4, 8, 5, 10, 6, 11]
+        ]
+        reconstructed = RGL::AdjacencyGraph.new
+        m.to_a.each { |edge| reconstructed.add_edge(*edge) }
+        expect(outcomes).to include(reconstructed)
+      end
+    end
+  end
+end

data/spec/graph_matching/algorithm/mcm_general_spec.rb

@@ -0,0 +1,159 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe GraphMatching::Algorithm::MCMGeneral do
+  let(:graph_class) { GraphMatching::Graph::Graph }
+  let(:g) { graph_class.new }
+
+  describe '.new' do
+    it 'requires a Graph' do
+      expect { described_class.new("banana") }.to raise_error(TypeError)
+    end
+  end
+
+  describe '#match' do
+    def complete_graph(n)
+      g = graph_class.new
+      1.upto(n - 1) do |i|
+        (i + 1).upto(n) do |j|
+          g.add_edge(i, j)
+        end
+      end
+      g
+    end
+
+    context 'empty graph' do
+      it 'returns empty set' do
+        expect(described_class.new(g).match).to be_empty
+      end
+    end
+
+    context 'single vertex' do
+      it 'returns empty set' do
+        g.add_vertex(1)
+        expect(described_class.new(g).match).to be_empty
+      end
+    end
+
+    context 'two vertexes' do
+      let(:g) { graph_class[1, 2] }
+
+      it 'returns one edge' do
+        m = described_class.new(g).match
+        expect(m.size).to eq(1)
+        expect(m).to match_edges [[1, 2]]
+      end
+    end
+
+    context 'complete graph with four vertexes' do
+      it 'returns two disjoint edges' do
+        g = graph_class[
+          1, 2,
+          1, 3,
+          1, 4,
+          2, 3,
+          2, 4,
+          3, 4
+        ]
+        m = described_class.new(g).match
+        expect(m.size).to eq(2)
+        expect(m.vertexes).to match_array([1, 2, 3, 4])
+      end
+    end
+
+    context 'graph with stem (123) and blossom (456)' do
+      it 'returns an expected result' do
+        g = graph_class[
+          1, 2,
+          2, 3,
+          3, 4,
+          4, 5,
+          5, 6,
+          6, 4
+        ]
+        m = described_class.new(g).match
+        expect(m.size).to eq(3)
+        expect(m).to match_edges [[1, 2], [3, 4], [5, 6]]
+      end
+    end
+
+    # TODO: Other algorithms (e.g. both MWM) support disconnected
+    # graphs.  MCM General should too.
+    context 'disconnected graph' do
+      it 'raises a DisconnectedGraph error' do
+        2.times { g.add_vertex(double) }
+        expect { described_class.new(g).match }.to \
+          raise_error(GraphMatching::DisconnectedGraph)
+      end
+    end
+
+    it 'simple example: graph with blossom (234)' do
+      g = graph_class[
+        1, 2,
+        2, 3,
+        2, 4,
+        3, 4,
+        4, 5,
+        5, 6
+      ]
+      m = described_class.new(g).match
+      expect(m.size).to eq(3)
+      expect(m).to match_edges [[1, 2], [3, 4], [5, 6]]
+    end
+
+    it 'example from West\'s Introduction to Graph Theory, p. 143' do
+      g = graph_class[
+        1, 2,
+        1, 8,
+        2, 3,
+        3, 4,
+        3, 7,
+        4, 5,
+        4, 7,
+        5, 6,
+        7, 9,
+        8, 9,
+        10, 8
+      ]
+      m = described_class.new(g).match
+      expect(m.size).to eq(5)
+      expect(m).to match_edges [[1, 2], [3, 4], [5, 6], [7, 9], [8, 10]]
+    end
+
+    it 'example from Gabow (1976)' do
+      g = graph_class[
+        1, 2,
+        2, 3,
+        1, 3,
+        1, 10,
+        3, 9,
+        3, 4,
+        4, 7,
+        4, 8,
+        7, 8,
+        9, 5,
+        5, 6,
+        6, 7
+      ]
+      m = described_class.new(g).match
+      expect(m).to match_edges [[10, 1], [2, 3], [4, 8], [7, 6], [5, 9]]
+    end
+
+    it 'various complete graphs' do
+      [
+        [1, 0], # size of graph, expected size of matching
+        [2, 1],
+        [3, 1],
+        [4, 2],
+        [5, 2],
+        [6, 3],
+        [20, 10]
+      ].each do |test|
+        g = complete_graph(test[0])
+        m = described_class.new(g).match
+        expect(m.size).to eq(test[1])
+      end
+    end
+  end
+end

data/spec/graph_matching/algorithm/mwm_bipartite_spec.rb

@@ -0,0 +1,82 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe GraphMatching::Algorithm::MWMBipartite do
+  let(:graph_class) { GraphMatching::Graph::WeightedBigraph }
+
+  describe '.new' do
+    it 'requires a WeightedBigraph' do
+      expect { described_class.new("banana") }.to raise_error(TypeError)
+    end
+  end
+
+  describe '#match' do
+    context 'empty graph' do
+      it 'returns the expected matching' do
+        g = graph_class.new
+        m = described_class.new(g).match
+        expect(m.size).to eq(0)
+        expect(m.weight(g)).to eq(0)
+      end
+    end
+
+    context 'trivial bigraph with two vertexes' do
+      it 'returns the expected matching' do
+        g = graph_class[[1, 2, 7]]
+        m = described_class.new(g).match
+        expect(m.size).to eq(1)
+        expect(m).to match_edges [[1, 2]]
+        expect(m.weight(g)).to eq(7)
+      end
+    end
+
+    context 'complete bigraph with three vertexes' do
+      it 'returns the expected matching' do
+        g = graph_class[
+          [1, 2, 1],
+          [1, 3, 2]
+        ]
+        m = described_class.new(g).match
+        expect(m).to match_edges [[1, 3]]
+        expect(m.weight(g)).to eq(2)
+      end
+
+      it 'supports negative weights' do
+        g = graph_class[
+          [1, 2, -1],
+          [1, 3, -3]
+        ]
+        m = described_class.new(g).match
+        expect(m).to match_edges [[1, 2]]
+        expect(m.weight(g)).to eq(-1)
+      end
+    end
+
+    context 'bigraph with two connected components' do
+      it 'returns one of two expected matchings' do
+        g = graph_class[
+          [1, 5, 3],
+          [2, 4, 2],
+          [2, 6, 2],
+          [3, 5, 3]
+        ]
+        m = described_class.new(g).match
+        expect(m.size).to eq(2)
+        expect(m.weight(g)).to eq(5)
+      end
+
+      it 'returns the expected matching' do
+        g = graph_class[
+          [1, 5, 4],
+          [2, 4, 2],
+          [2, 6, 1],
+          [3, 5, 3]
+        ]
+        m = described_class.new(g).match
+        expect(m).to match_edges [[1, 5], [2, 4]]
+        expect(m.weight(g)).to eq(6)
+      end
+    end
+  end
+end

data/spec/graph_matching/algorithm/mwm_general_spec.rb

@@ -0,0 +1,439 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe GraphMatching::Algorithm::MWMGeneral do
+  let(:graph_class) { GraphMatching::Graph::WeightedGraph }
+
+  describe '.new' do
+    it 'requires a WeightedGraph' do
+      expect { described_class.new("banana") }.to raise_error(TypeError)
+    end
+  end
+
+  describe '#blossom_leaves' do
+    context 'five vertexes, one blossom' do
+      it 'returns array of leaves' do
+        g = graph_class[
+          [0, 1, 0],
+          [1, 2, 0],
+          [1, 3, 0],
+          [2, 3, 0],
+          [3, 4, 0]
+        ]
+        a = described_class.new(g)
+        a.instance_variable_set(:@blossom_children, [
+          nil,
+          nil,
+          nil,
+          nil,
+          nil,
+          [2, 3, 4]
+        ])
+        expect(a.send(:blossom_leaves, 0)).to eq([0])
+        expect(a.send(:blossom_leaves, 4)).to eq([4])
+        expect(a.send(:blossom_leaves, 5)).to eq([2, 3, 4])
+      end
+    end
+  end
+
+  describe '#match' do
+    context 'empty graph' do
+      it 'returns empty matching' do
+        g = graph_class.new
+        m = described_class.new(g).match(true)
+        expect(m).to be_empty
+      end
+    end
+
+    context 'single vertex' do
+      it 'returns empty matching' do
+        g = graph_class.new
+        g.add_vertex(0)
+        m = described_class.new(g).match(true)
+        expect(m).to be_empty
+      end
+    end
+
+    context 'two vertexes, but no edge' do
+      it 'returns empty matching' do
+        g = graph_class.new
+        g.add_vertex(0)
+        g.add_vertex(1)
+        m = described_class.new(g).match(true)
+        expect(m).to be_empty
+      end
+    end
+
+    context 'two vertexes' do
+      it 'returns matching of size 1' do
+        g = graph_class[[0, 1, 7]]
+        m = described_class.new(g).match(true)
+        expect(m).to match_edges [[0, 1]]
+        expect(m.weight(g)).to eq(7)
+      end
+    end
+
+    context 'three vertexes' do
+      it 'matches the edge with greater weight' do
+        g = graph_class[
+          [0, 1, 1],
+          [1, 2, 2],
+          [2, 0, 3]
+        ]
+        m = described_class.new(g).match(true)
+        expect(m).to match_edges [[0, 2]]
+        expect(m.weight(g)).to eq(3)
+      end
+    end
+
+    context 'greatest weight edge cannot be used in complete matching' do
+      it 'returns the complete matching with max. weight' do
+        # In the following graph, edge 1=3 has the greatest weight,
+        # but that edge cannot be used in a complete matching.
+        g = graph_class[
+          [0, 1, 2],
+          [1, 2, 0],
+          [1, 3, 6],
+          [2, 3, 4],
+          [3, 4, 2]
+        ]
+        m = described_class.new(g).match(true)
+        expect(m).to match_edges [[0, 1], [2, 3]]
+        expect(m.weight(g)).to eq(6)
+      end
+    end
+
+    it "passes Van Rantwijk test 12" do
+      g = graph_class[[1, 2, 10], [2, 3, 11]]
+      m = described_class.new(g).match(false)
+      expect(m).to match_edges [[2, 3]]
+      expect(m.weight(g)).to eq(11)
+    end
+
+    it "passes Van Rantwijk test 13" do
+      g = graph_class[
+        [1, 2, 5],
+        [2, 3, 11],
+        [3, 4, 5]
+      ]
+      m = described_class.new(g).match(false)
+      expect(m).to match_edges [[2, 3]]
+      expect(m.weight(g)).to eq(11)
+    end
+
+    it "passes Van Rantwijk test 14: max. cardinality" do
+      g = graph_class[
+        [1, 2, 5],
+        [2, 3, 11],
+        [3, 4, 5]
+      ]
+      m = described_class.new(g).match(true)
+      expect(m).to match_edges [[1, 2], [3, 4]]
+      expect(m.weight(g)).to eq(10)
+    end
+
+    it "passes Van Rantwijk test 15: floating-point weights" do
+      g = graph_class[
+        [1, 2, Math::PI],
+        [2, 3, Math.exp(1)],
+        [1, 3, 3.0],
+        [1, 4, Math.sqrt(2.0)]
+      ]
+      m = described_class.new(g).match(false)
+      expect(m).to match_edges [[1, 4], [2, 3]]
+      expect(m.weight(g)).to be_within(0.00001).of(Math.sqrt(2.0) + Math.exp(1))
+    end
+
+    it "passes Van Rantwijk test 16: negative weights" do
+      g = graph_class[
+        [1, 2, 2],
+        [1, 3, -2],
+        [2, 3, 1],
+        [2, 4, -1],
+        [3, 4, -6]
+      ]
+      m = described_class.new(g).match(false)
+      expect(m).to match_edges [[1, 2]]
+      expect(m.weight(g)).to eq(2)
+      m = described_class.new(g).match(true)
+      expect(m).to match_edges [[1, 3], [2, 4]]
+      expect(m.weight(g)).to eq(-3)
+    end
+
+    context "Van Rantwijk test 20: Uses S-blossom for augmentation" do
+      it "passes test 20-A" do
+        g = graph_class[
+          [1, 2, 8],
+          [1, 3, 9],
+          [2, 3, 10],
+          [3, 4, 7]
+        ]
+        m = described_class.new(g).match(false)
+        expect(m).to match_edges [[1, 2], [3, 4]]
+        expect(m.weight(g)).to eq(15)
+      end
+
+      it "passes test 20-B" do
+        g = graph_class[
+          [1, 2, 8],
+          [1, 3, 9],
+          [2, 3, 10],
+          [3, 4, 7],
+          [1, 6, 5],
+          [4, 5, 6]
+        ]
+        m = described_class.new(g).match(false)
+        expect(m).to match_edges [[1, 6], [2, 3], [4, 5]]
+        expect(m.weight(g)).to eq(21)
+      end
+    end
+
+    # Van Rantwijk test 21
+    context "create S-blossom, relabel as T-blossom, use for augmentation" do
+      it "passes test 21-A" do
+        g = graph_class[
+          [1, 2, 9],
+          [1, 3, 8],
+          [2, 3, 10],
+          [1, 4, 5],
+          [4, 5, 4],
+          [1, 6, 3]
+        ]
+        m = described_class.new(g).match(false)
+        expect(m).to match_edges [[1, 6], [2, 3], [4, 5]]
+      end
+
+      it "passes test 21-B" do
+        g = graph_class[
+          [1, 2, 9],
+          [1, 3, 8],
+          [2, 3, 10],
+          [1, 4, 5],
+          [4, 5, 3],
+          [1, 6, 4]
+        ]
+        m = described_class.new(g).match(false)
+        expect(m).to match_edges [[1, 6], [2, 3], [4, 5]]
+      end
+
+      it "passes test 21-C" do
+        g = graph_class[
+          [1, 2, 9],
+          [1, 3, 8],
+          [2, 3, 10],
+          [1, 4, 5],
+          [4, 5, 3],
+          [3, 6, 4]
+        ]
+        m = described_class.new(g).match(false)
+        expect(m).to match_edges [[1, 2], [3, 6], [4, 5]]
+      end
+    end
+
+    context "Van Rantwijk test 22" do
+      it "creates nested S-blossom, uses for augmentation" do
+        g = graph_class[
+          [1, 2, 9],
+          [1, 3, 9],
+          [2, 3, 10],
+          [2, 4, 8],
+          [3, 5, 8],
+          [4, 5, 10],
+          [5, 6, 6]
+        ]
+        m = described_class.new(g).match(false)
+        expect(m).to match_edges [[1, 3], [2, 4], [5, 6]]
+      end
+    end
+
+    context "Van Rantwijk test 23" do
+      it "create S-blossom, relabel as S, include in nested S-blossom" do
+        g = graph_class[
+          [1, 2, 10],
+          [1, 7, 10],
+          [2, 3, 12],
+          [3, 4, 20],
+          [3, 5, 20],
+          [4, 5, 25],
+          [5, 6, 10],
+          [6, 7, 10],
+          [7, 8, 8]
+        ]
+        m = described_class.new(g).match(false)
+        expect(m).to match_edges [[1, 2], [3, 4], [5, 6], [7, 8]]
+      end
+    end
+
+    context "Van Rantwijk test 24" do
+      it "create nested S-blossom, augment, expand recursively" do
+        g = graph_class[
+          [1, 2, 8],
+          [1, 3, 8],
+          [2, 3, 10],
+          [2, 4, 12],
+          [3, 5, 12],
+          [4, 5, 14],
+          [4, 6, 12],
+          [5, 7, 12],
+          [6, 7, 14],
+          [7, 8, 12]
+        ]
+        m = described_class.new(g).match(false)
+        expect(m).to match_edges [[1, 2], [3, 5], [4, 6], [7, 8]]
+      end
+    end
+
+    context "Van Rantwijk test 25" do
+      it "create S-blossom, relabel as T, expand" do
+        g = graph_class[
+          [1, 2, 23],
+          [1, 5, 22],
+          [1, 6, 15],
+          [2, 3, 25],
+          [3, 4, 22],
+          [4, 5, 25],
+          [4, 8, 14],
+          [5, 7, 13]
+        ]
+        m = described_class.new(g).match(false)
+        expect(m).to match_edges [[1, 6], [2, 3], [4, 8], [5, 7]]
+      end
+    end
+
+    context "Van Rantwijk test 26" do
+      it "create nested S-blossom, relabel as T, expand" do
+        g = graph_class[
+          [1, 2, 19],
+          [1, 3, 20],
+          [1, 8, 8],
+          [2, 3, 25],
+          [2, 4, 18],
+          [3, 5, 18],
+          [4, 5, 13],
+          [4, 7, 7],
+          [5, 6, 7]
+        ]
+        m = described_class.new(g).match(false)
+        expect(m).to match_edges [[1, 8], [2, 3], [4, 7], [5, 6]]
+      end
+    end
+
+    context "Van Rantwijk test 30" do
+      it "create blossom, relabel as T in more than one way, expand, augment" do
+        g = graph_class[
+          [1, 2, 45],
+          [1, 5, 45],
+          [2, 3, 50],
+          [3, 4, 45],
+          [4, 5, 50],
+          [1, 6, 30],
+          [3, 9, 35],
+          [4, 8, 35],
+          [5, 7, 26],
+          [9, 10, 5]
+        ]
+        m = described_class.new(g).match(false)
+        expect(m).to match_edges [[1, 6], [2, 3], [4, 8], [5, 7], [9, 10]]
+      end
+    end
+
+    context "Van Rantwijk test 31" do
+      it "similar to test 30, but slightly different" do
+        g = graph_class[
+          [1, 2, 45],
+          [1, 5, 45],
+          [2, 3, 50],
+          [3, 4, 45],
+          [4, 5, 50],
+          [1, 6, 30],
+          [3, 9, 35],
+          [4, 8, 26], # differs from test 30
+          [5, 7, 40], # differs from test 30
+          [9, 10, 5]
+        ]
+        m = described_class.new(g).match(false)
+        expect(m).to match_edges [[1, 6], [2, 3], [4, 8], [5, 7], [9, 10]]
+      end
+    end
+
+    context "Van Rantwijk test 32" do
+      # create blossom, relabel as T, expand such that a new
+      # least-slack S-to-free edge is produced, augment
+      it "see comment" do
+        g = graph_class[
+          [1, 2, 45],
+          [1, 5, 45],
+          [2, 3, 50],
+          [3, 4, 45],
+          [4, 5, 50],
+          [1, 6, 30],
+          [3, 9, 35],
+          [4, 8, 28],
+          [5, 7, 26],
+          [9, 10, 5]
+        ]
+        m = described_class.new(g).match(false)
+        expect(m).to match_edges [[1, 6], [2, 3], [4, 8], [5, 7], [9, 10]]
+      end
+    end
+
+    context "Van Rantwijk test 33" do
+      # create nested blossom, relabel as T in more than one way,
+      # expand outer blossom such that inner blossom ends up on
+      # an augmenting path
+      it "see comment" do
+        g = graph_class[
+          [1, 2, 45],
+          [1, 7, 45],
+          [2, 3, 50],
+          [3, 4, 45],
+          [4, 5, 95],
+          [4, 6, 94],
+          [5, 6, 94],
+          [6, 7, 50],
+          [1, 8, 30],
+          [3, 11, 35],
+          [5, 9, 36],
+          [7, 10, 26],
+          [11, 12, 5]
+        ]
+        m = described_class.new(g).match(false)
+        expect(m).to match_edges [
+          [1, 8],
+          [2, 3],
+          [4, 6],
+          [5, 9],
+          [7, 10],
+          [11, 12]
+        ]
+      end
+    end
+
+    context "Van Rantwijk test 34: nest, relabel, expand" do
+      it "create nested S-blossom, relabel as S, expand recursively" do
+        g = graph_class[
+          [1, 2, 40],
+          [1, 3, 40],
+          [2, 3, 60],
+          [2, 4, 55],
+          [3, 5, 55],
+          [4, 5, 50],
+          [1, 8, 15],
+          [5, 7, 30],
+          [7, 6, 10],
+          [8, 10, 10],
+          [4, 9, 30]
+        ]
+        m = described_class.new(g).match(false)
+        expect(m).to match_edges [
+          [1, 2],
+          [3, 5],
+          [4, 9],
+          [6, 7],
+          [8, 10]
+        ]
+      end
+    end
+  end
+end