graph_matching 0.1.0 → 0.1.1

data/spec/graph_matching/algorithm/matching_algorithm_spec.rb

@@ -1,14 +0,0 @@
-# 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

@@ -1,98 +0,0 @@
-# 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

@@ -1,159 +0,0 @@
-# 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

@@ -1,82 +0,0 @@
-# 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

@@ -1,442 +0,0 @@
-# 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