graph_matching 0.0.1

data/spec/graph_matching/graph/bigraph_spec.rb

@@ -0,0 +1,73 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe GraphMatching::Graph::Bigraph do
+  let(:g) { described_class.new }
+
+  it 'is a Graph' do
+    expect(g).to be_a(GraphMatching::Graph::Graph)
+  end
+
+  describe '#partition' do
+    context 'empty graph' do
+      it 'returns two empty sets' do
+        p = g.partition
+        expect(p.length).to eq(2)
+        p.each do |set|
+          expect(set).to be_a(Set)
+          expect(set).to be_empty
+        end
+      end
+    end
+
+    context 'graph with single vertex v' do
+      it 'returns two sets, one with v' do
+        v = 0
+        g.add_vertex(v)
+        p = g.partition
+        expect(p[0]).to eq(Set[v])
+        expect(p[1]).to eq(Set[])
+      end
+    end
+
+    context 'graph with single edge' do
+      it 'returns two disjoint sets, each with one vertex' do
+        e = [0, 1]
+        g.add_edge(*e)
+        p = g.partition
+        expect(p.map(&:first)).to match_array(e)
+      end
+    end
+
+    context 'complete graph with three vertexes' do
+      it 'raises a NotBipartite error' do
+        g.add_edge('alice', 'bob')
+        g.add_edge('bob', 'carol')
+        g.add_edge('alice', 'carol')
+        expect { g.partition }.to \
+          raise_error(GraphMatching::NotBipartite)
+      end
+    end
+
+    context 'non-trivial bipartite graph' do
+      it 'returns the expected disjoint sets' do
+        g.add_edge(1, 3)
+        g.add_edge(1, 4)
+        g.add_edge(2, 3)
+        g.add_edge(2, 4)
+        p = g.partition.map(&:sort).sort_by(&:first)
+        expect(p).to match_array([[1, 2], [3, 4]])
+      end
+    end
+
+    context 'disconnected, yet bipartite graph' do
+      it 'returns one of the the expected disjoint sets' do
+        g = described_class[1, 3, 2, 4]
+        p = g.partition.map(&:sort).sort_by(&:first)
+        permutations = [[[1, 2], [3, 4]], [[1, 4], [2, 3]]]
+        expect(permutations).to include(p)
+      end
+    end
+  end
+end

data/spec/graph_matching/graph/graph_spec.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe GraphMatching::Graph::Graph do
+  ERR_MSG_INT_VERTEXES = 'All vertexes must be integers'
+
+  let(:g) { described_class.new }
+
+  it 'is an RGL::MutableGraph' do
+    expect(g).to be_a(RGL::MutableGraph)
+  end
+
+  describe '.[]' do
+    it 'checks that all vertexes are integers' do
+      expect { described_class['a', 'b'] }.to \
+        raise_error(ArgumentError, ERR_MSG_INT_VERTEXES)
+    end
+  end
+
+  describe '.new' do
+    it 'checks that all vertexes are integers' do
+      g1 = RGL::AdjacencyGraph[1, 'b']
+      g2 = RGL::AdjacencyGraph['a', 2]
+      expect { described_class.new(Set, g1, g2) }.to \
+        raise_error(ArgumentError, ERR_MSG_INT_VERTEXES)
+    end
+  end
+
+  describe '#connected?' do
+    it 'returns true for a connected graph' do
+      g.add_edge('alice', 'bob')
+      expect(g).to be_connected
+    end
+
+    it 'returns false for a disconnected graph' do
+      g.add_edge('alice', 'bob')
+      g.add_edge('yvette', 'zach')
+      expect(g).to_not be_connected
+    end
+  end
+
+  describe "#max_v" do
+    it "returns the largest vertex number" do
+      g = described_class[1, 3, 3, 7]
+      expect(g.max_v).to eq(7)
+    end
+
+    it "returns nil when graph is empty" do
+      expect(g.max_v).to eq(nil)
+    end
+  end
+end

data/spec/graph_matching/graph/weighted_spec.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe GraphMatching::Graph::Weighted do
+  # no-doc
+  class MyGraph < RGL::AdjacencyGraph
+    include GraphMatching::Graph::Weighted
+  end
+
+  describe '.[]' do
+    it 'sets weights' do
+      g = MyGraph[[1, 2, 100], [1, 3, 101]]
+      expect(g.w([1, 2])).to eq(100)
+      expect(g.w([1, 3])).to eq(101)
+    end
+  end
+
+  describe '#set_w' do
+    let(:g) { MyGraph[[1, 2, 100]] }
+    let(:edge) { [1, 2] }
+
+    it 'records the assigned weight' do
+      weight = 7
+      g.set_w(edge, weight)
+      expect(g.w(edge)).to eq(weight)
+    end
+  end
+end

data/spec/graph_matching/integer_vertexes_spec.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'rgl/adjacency'
+require 'spec_helper'
+require 'graph_matching/integer_vertexes'
+
+RSpec.describe GraphMatching::IntegerVertexes do
+  describe '.to_integers' do
+    it 'returns new graph with vertexes converted to integers, and a legend' do
+      e = %w[a b]
+      g1 = RGL::AdjacencyGraph[*e]
+      g2, legend = described_class.to_integers(g1)
+      expect(g2.size).to eq(g1.size)
+      expect(g2.vertices).to eq(1.upto(g1.size).to_a)
+      expect(g2.num_edges).to eq(g1.num_edges)
+      legend.keys.map(&:class).uniq.each do |klass|
+        expect(klass).to be < Integer
+      end
+    end
+  end
+end

data/spec/graph_matching/matching_spec.rb

@@ -0,0 +1,89 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe GraphMatching::Matching do
+  describe '.gabow' do
+    context 'when nil is used as a placeholder' do
+      it 'returns a Matching' do
+        a = [nil, 2, 1, nil, 5, 4]
+        m = described_class.gabow(a)
+        expect(m.edge?([1, 2])).to eq(true)
+        expect(m.edge?([4, 5])).to eq(true)
+        expect(m.vertex?(3)).to eq(false)
+      end
+    end
+
+    context 'when 0 is used as a placeholder' do
+      it 'returns a Matching' do
+        a = [0, 2, 1]
+        m = described_class.gabow(a)
+        expect(m.edge?([1, 2])).to eq(true)
+        expect(m.vertex?(3)).to eq(false)
+      end
+    end
+  end
+
+  describe '#delete' do
+    it 'removes edge' do
+      e = [2, 3]
+      m = described_class[e]
+      expect(m.edge?(e)).to eq(true)
+      m.delete(e)
+      expect(m.edge?(e)).to eq(false)
+    end
+  end
+
+  describe '#empty?' do
+    context 'when initialized' do
+      it 'returns true' do
+        expect(described_class.new.empty?).to eq(true)
+      end
+    end
+
+    context 'with one or more edges' do
+      it 'returns false' do
+        expect(described_class[[1, 2]].empty?).to eq(false)
+      end
+    end
+  end
+
+  describe '#edge?' do
+    it 'returns true if edge found' do
+      m = described_class.new
+      expect(m.edge?([1, 2])).to eq(false)
+      m.add([1, 2])
+      expect(m.edge?([1, 2])).to eq(true)
+      m.add([4, 3])
+      expect(m.edge?([3, 4])).to eq(true)
+    end
+  end
+
+  describe '#vertex?' do
+    it 'returns true if vertex found' do
+      m = described_class.new
+      expect(m.vertex?(1)).to eq(false)
+      expect(m.vertex?(2)).to eq(false)
+      m.add([1, 2])
+      expect(m.vertex?(1)).to eq(true)
+      expect(m.vertex?(2)).to eq(true)
+    end
+  end
+
+  describe '#to_a' do
+    it 'returns edges' do
+      edges = [[1, 2], [3, 4]]
+      m = described_class[*edges]
+      expect(m.to_a).to eq(edges)
+    end
+  end
+
+  describe '#vertexes' do
+    it 'returns array of matched vertexes' do
+      expect(described_class.new.vertexes).to be_empty
+      expect(described_class[[3, 4]].vertexes).to match_array([3, 4])
+      expect(described_class[[1, 2], [3, 4]].vertexes).to \
+        match_array([1, 2, 3, 4])
+    end
+  end
+end

data/spec/graph_matching/visualize_spec.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+require_relative '../spec_helper'
+
+RSpec.describe GraphMatching::Visualize do
+  describe '.new' do
+    it 'initializes with a graph' do
+      g = double
+      v = described_class.new(g)
+      expect(v.graph).to eq(g)
+    end
+  end
+
+  describe '#dot' do
+    let(:g) { GraphMatching::Graph::Graph.new }
+
+    def normalize_ws(str)
+      str.gsub(/\s+/, ' ').strip
+    end
+
+    context 'given a graph with a single edge' do
+      it 'returns a string in .dot format' do
+        g.add_edge('alice', 'bob')
+        str = described_class.new(g).dot
+        expect(normalize_ws(str)).to eq('graph { alice -- bob }')
+      end
+    end
+
+    context 'given a graph with two edges' do
+      it 'returns a string in .dot format' do
+        g.add_edge('alice', 'bob')
+        g.add_edge('tom', 'jerry')
+        str = described_class.new(g).dot
+        expect(normalize_ws(str)).to eq('graph { alice -- bob tom -- jerry }')
+      end
+    end
+  end
+end

data/spec/graph_matching_spec.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe GraphMatching do
+  it 'should have a version number' do
+    expect(GraphMatching::VERSION).to_not be_nil
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'graph_matching'
+require 'pry'
+
+RSpec.configure do |config|
+  config.disable_monkey_patching!
+  config.filter_run_including(focus: true)
+  config.run_all_when_everything_filtered = true
+end
+
+RSpec::Matchers.define(:match_edges) do |expected|
+  match do |matching|
+    fail TypeError unless matching.is_a?(GraphMatching::Matching)
+    fail TypeError unless expected.is_a?(Array)
+    se = Set.new(expected.map { |e| RGL::Edge::UnDirectedEdge.new(*e) })
+    sa = Set.new(matching.undirected_edges)
+    se == sa
+  end
+
+  failure_message do |matching|
+    edges_desc = to_sentence(expected)
+    "expected #{matching.edges} to equal" + edges_desc
+  end
+end

metadata

@@ -0,0 +1,263 @@
+--- !ruby/object:Gem::Specification
+name: graph_matching
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Jared Beck
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rgl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-nav
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: rspec-expectations
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: rspec-mocks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |2
+      Efficient algorithms for maximum cardinality
+      and weighted matchings in undirected graphs.
+email:
+- jared@jaredbeck.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- ".ruby-version"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- benchmark/mcm_bipartite/complete_bigraphs/benchmark.rb
+- benchmark/mcm_bipartite/complete_bigraphs/compare.gnuplot
+- benchmark/mcm_bipartite/complete_bigraphs/edges_times_vertexes.data
+- benchmark/mcm_bipartite/complete_bigraphs/plot.gnuplot
+- benchmark/mcm_bipartite/complete_bigraphs/plot.png
+- benchmark/mcm_bipartite/complete_bigraphs/time.data
+- benchmark/mcm_general/complete_graphs/benchmark.rb
+- benchmark/mcm_general/complete_graphs/plot.gnuplot
+- benchmark/mcm_general/complete_graphs/plot.png
+- benchmark/mcm_general/complete_graphs/time.data
+- benchmark/mcm_general/complete_graphs/v_cubed.data
+- benchmark/mwm_bipartite/complete_bigraphs/benchmark.rb
+- benchmark/mwm_bipartite/complete_bigraphs/nmN.data
+- benchmark/mwm_bipartite/complete_bigraphs/nmN.xlsx
+- benchmark/mwm_bipartite/complete_bigraphs/plot.gnuplot
+- benchmark/mwm_bipartite/complete_bigraphs/plot.png
+- benchmark/mwm_bipartite/complete_bigraphs/time.data
+- benchmark/mwm_bipartite/misc/calc_d2/benchmark.rb
+- benchmark/mwm_general/complete_graphs/benchmark.rb
+- benchmark/mwm_general/complete_graphs/compare.gnuplot
+- benchmark/mwm_general/complete_graphs/mn_log_n.data
+- benchmark/mwm_general/complete_graphs/mn_log_n.xlsx
+- benchmark/mwm_general/complete_graphs/plot.gnuplot
+- benchmark/mwm_general/complete_graphs/plot.png
+- benchmark/mwm_general/complete_graphs/time.data
+- benchmark/mwm_general/incomplete_graphs/benchmark.rb
+- benchmark/mwm_general/incomplete_graphs/plot.gnuplot
+- benchmark/mwm_general/incomplete_graphs/plot.png
+- benchmark/mwm_general/incomplete_graphs/time_10_pct.data
+- benchmark/mwm_general/incomplete_graphs/time_20_pct.data
+- benchmark/mwm_general/incomplete_graphs/time_30_pct.data
+- graph_matching.gemspec
+- lib/graph_matching.rb
+- lib/graph_matching/algorithm/matching_algorithm.rb
+- lib/graph_matching/algorithm/mcm_bipartite.rb
+- lib/graph_matching/algorithm/mcm_general.rb
+- lib/graph_matching/algorithm/mwm_bipartite.rb
+- lib/graph_matching/algorithm/mwm_general.rb
+- lib/graph_matching/algorithm/mwmg_delta_assertions.rb
+- lib/graph_matching/assertion.rb
+- lib/graph_matching/core_ext/set.rb
+- lib/graph_matching/directed_edge_set.rb
+- lib/graph_matching/errors.rb
+- lib/graph_matching/graph/bigraph.rb
+- lib/graph_matching/graph/graph.rb
+- lib/graph_matching/graph/weighted.rb
+- lib/graph_matching/graph/weighted_bigraph.rb
+- lib/graph_matching/graph/weighted_graph.rb
+- lib/graph_matching/integer_vertexes.rb
+- lib/graph_matching/matching.rb
+- lib/graph_matching/ordered_set.rb
+- lib/graph_matching/version.rb
+- lib/graph_matching/visualize.rb
+- profile/mcm_bipartite/compare.sh
+- profile/mcm_bipartite/publish.sh
+- profile/mwm_general/compare.sh
+- profile/mwm_general/profile.rb
+- profile/mwm_general/publish.sh
+- research/1965_edmonds.pdf
+- research/1975_even_kariv.pdf
+- research/1976_gabow.pdf
+- research/1980_micali_vazirani.pdf
+- research/1985_gabow.pdf
+- research/2002_tarjan.pdf
+- research/2013_zwick.pdf
+- research/examples/unweighted_general/1.txt
+- research/goodwin.pdf
+- research/kavathekar-scribe.pdf
+- research/kusner.pdf
+- research/van_rantwijk/mwm_example.py
+- research/van_rantwijk/mwmatching.py
+- spec/graph_matching/algorithm/matching_algorithm_spec.rb
+- spec/graph_matching/algorithm/mcm_bipartite_spec.rb
+- spec/graph_matching/algorithm/mcm_general_spec.rb
+- spec/graph_matching/algorithm/mwm_bipartite_spec.rb
+- spec/graph_matching/algorithm/mwm_general_spec.rb
+- spec/graph_matching/graph/bigraph_spec.rb
+- spec/graph_matching/graph/graph_spec.rb
+- spec/graph_matching/graph/weighted_spec.rb
+- spec/graph_matching/integer_vertexes_spec.rb
+- spec/graph_matching/matching_spec.rb
+- spec/graph_matching/visualize_spec.rb
+- spec/graph_matching_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/jaredbeck/graph_matching
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Finds maximum matchings in undirected graphs.
+test_files:
+- spec/graph_matching/algorithm/matching_algorithm_spec.rb
+- spec/graph_matching/algorithm/mcm_bipartite_spec.rb
+- spec/graph_matching/algorithm/mcm_general_spec.rb
+- spec/graph_matching/algorithm/mwm_bipartite_spec.rb
+- spec/graph_matching/algorithm/mwm_general_spec.rb
+- spec/graph_matching/graph/bigraph_spec.rb
+- spec/graph_matching/graph/graph_spec.rb
+- spec/graph_matching/graph/weighted_spec.rb
+- spec/graph_matching/integer_vertexes_spec.rb
+- spec/graph_matching/matching_spec.rb
+- spec/graph_matching/visualize_spec.rb
+- spec/graph_matching_spec.rb
+- spec/spec_helper.rb