graphsrb 0.1.0

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "graphsrb"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/examples/ApproxAlgs/TSP/tsp.rb

@@ -0,0 +1,45 @@
+require 'graphsrb'
+require_relative '../../PrimMST/prim'
+include Graphsrb
+
+# 2-approximation for TSP
+module ApproxAlgs
+  module TSP
+    def self.run(graph)
+      edges = PrimMST.run(graph)
+      #Create a spanning tree
+      @spanning_tree = Graph.new
+      edges.each{|e| @spanning_tree.add_edge(e.initial_vertex.id, e.terminal_vertex.id)}
+
+      puts "Spanning tree:"
+      puts @spanning_tree.edges
+      puts "-"*25
+      compute_path(edges.first.initial_vertex)
+    end
+
+    def self.compute_path(start)
+      @stack = [start]
+      @visited = []
+      dfs(start)
+      return @stack.uniq
+    end
+
+    def self.dfs(v)
+      @stack.push(v)
+      @visited[v.id] = true
+      @spanning_tree.adjacent_vertices(v).each do |v|
+        dfs(v) if !@visited[v.id]
+      end
+    end
+  end
+end
+
+edges = [
+  [1,2,6], [1,3,3], [1,4,5],[1,5,5],
+  [2,3,4], [2,4,4], [2,5,2],
+  [3,4,3], [3,5,4],
+  [4,5,4]
+]
+
+
+puts ApproxAlgs::TSP.run(Graph.new(edges:edges))

data/examples/ApproxAlgs/VertexCover/main.rb

@@ -0,0 +1,34 @@
+require_relative 'vertex_cover'
+
+def run_example(example_title, graph)
+  puts "------- #{example_title} ------ "
+  puts "The graph has #{graph.vertex_count} vertices and #{graph.edge_count} edges"
+  ApproxAlgs::VertexCover.run(graph)
+end
+
+
+def main
+  edges = [
+    [1,2],[1,4],
+    [2,3],[2,5],
+    [3,5],[3,6],[3,7],
+    [5,6]
+  ]
+  vertices = run_example('Example 1', Graph.new(edges:edges))
+  vertices.each {|v| puts v}
+
+
+  edges = [[1,2],[2,3],[3,4],[4,5]]
+  vertices = run_example('Example 2', Graph.new(edges:edges))
+  vertices.each {|v| puts v}
+
+  edges = [[1,2],[3,4],[5,6],[7,8]]
+  vertices = run_example('Example 3', Graph.new(edges:edges))
+  vertices.each {|v| puts v}
+
+  edges = [[1,2],[1,3],[1,4],[1,5]]
+  vertices = run_example('Example 4', Graph.new(edges:edges))
+  vertices.each {|v| puts v}
+end
+
+main

data/examples/ApproxAlgs/VertexCover/vertex_cover.rb

@@ -0,0 +1,31 @@
+require 'graphsrb'
+include Graphsrb
+
+# 2-approximation for vertex-cover problem
+module ApproxAlgs
+  module VertexCover
+    def self.run(graph)
+      vertex_cover = []
+      edges = graph.edges
+
+      while edges.size > 0
+        edge = edges.first
+        v = edge.initial_vertex
+        u = edge.terminal_vertex
+        vertex_cover.concat([v,u])
+        edges = remove_incident_edges(edges, u, v)
+      end
+      vertex_cover
+    end
+
+    def self.remove_incident_edges(edges, v, u)
+      remaining_edges = []
+      edges.each do |e|
+        next if e.initial_vertex == v || e.terminal_vertex == v
+        next if e.initial_vertex == u || e.terminal_vertex == u
+        remaining_edges << e
+      end
+      remaining_edges
+    end
+  end
+end

data/examples/Apts/artc_points.rb

@@ -0,0 +1,59 @@
+require 'graphsrb'
+include Graphsrb
+
+#Computes articulation points
+module ArtcPoints
+  def self.run(g)
+    init(g)
+    root = @graph.vertices.first
+    dfs(root)
+    @apts = @apts - [root]
+    @apts << root if root_artc_point?(root)
+    @apts
+  end
+
+  def self.init(g)
+    @graph = g
+    @apts = []
+    @dfi = []
+    @low = []
+    @preds = []
+    @index = 1
+
+    @graph.vertices.each do |u|
+      @dfi[u.id] = 0
+    end
+  end
+
+  def self.root_artc_point?(root)
+    count = 0
+    @graph.vertices.each do |u|
+      next if root == u
+      count+=1 if @preds[u.id] == root.id
+    end
+
+    return count > 1
+  end
+
+  def self.dfs(v)
+    @dfi[v.id] = @index
+    min = @index
+    @index += 1
+
+    @graph.vertices.each do |u|
+      if @graph.has_edge?(v.id, u.id)
+        if @dfi[u.id] == 0
+          @preds[u.id] = v.id
+          dfs(u)
+          @apts << v if @low[u.id] >= @dfi[v.id]
+          min = @low[u.id] if @low[u.id] < min
+        else #found a backedge
+          if u.id != @preds[v.id]
+            min = @dfi[u.id] if @dfi[u.id] < min
+          end
+        end
+      end
+    end
+    @low[v.id] = min
+  end
+end

data/examples/Apts/main.rb

@@ -0,0 +1,51 @@
+require_relative 'artc_points'
+
+def run_example(example_title, graph)
+  puts "------- #{example_title} ------ "
+  puts "The graph has #{graph.vertex_count} vertices and #{graph.edge_count} edges"
+  apts = ArtcPoints.run(graph)
+  puts "Articulation points:"
+  apts.each{|v| puts v}
+end
+
+def main
+  edges = [
+    [1,2],[1,8],
+    [2,3],[2,7],
+    [3,4],
+    [4,5],[4,7],[4,6],
+    [5,6],
+    [7,8]
+  ]
+  run_example('Example 1', Graph.new(edges:edges))
+
+  edges = [
+    [1,2],[1,3],[1,4],[1,5],[1,6],[1,7],[1,8],
+    [2,5],[2,6],[2,8],
+    [3,4],[3,7]
+  ]
+  run_example('Example 2', Graph.new(edges:edges))
+
+  edges = [
+    [9,10],[9,13],
+    [10,11],[10,12],[10,13],
+    [11,12]
+  ]
+  run_example('Example 3', Graph.new(edges:edges))
+
+  edges = [[1,2], [2,3], [3,4]]
+  run_example('Example 4', Graph.new(edges:edges))
+
+  edges = [
+    [1,2],[1,3],
+    [2,3],
+    [3,4],[3,5],
+    [4,5]
+  ]
+  run_example('Example 5', Graph.new(edges:edges))
+
+  edges = [[1,2], [2,3], [3,4], [4,1]]
+  run_example('Example 6', Graph.new(edges:edges))
+end
+
+main

data/examples/BackEdges/backedges.rb

@@ -0,0 +1,37 @@
+require 'graphsrb'
+include Graphsrb
+
+module BackEdges
+  def self.run(graph)
+    init(graph)
+    @graph.vertices.each do |v|
+      dfs(v) if @dfi[v.id] == 0
+    end
+    @forest
+  end
+
+
+  def self.init(graph)
+    @graph = graph
+    @forest = []
+    @index = 1
+    @dfi = []
+
+    @graph.vertices.each do |v|
+      @dfi[v.id] = 0
+    end
+  end
+
+  def self.dfs(v)
+    @dfi[v.id] = @index
+    @index += 1
+
+    vertices = @graph.adjacent_vertices(v)
+    vertices.each do |u|
+      if @dfi[u.id] == 0
+        @forest << @graph.edge(v, u)
+        dfs(u)
+      end
+    end
+  end
+end

data/examples/BackEdges/main.rb

@@ -0,0 +1,41 @@
+require_relative 'backedges'
+
+def run_example(example_title, graph)
+  puts "------- #{example_title} ------ "
+  puts "The graph has #{graph.vertex_count} vertices and #{graph.edge_count} edges"
+  #Compute forest edges using depth first search algorithm
+  forest = BackEdges.run(graph)
+  puts "Forest:"
+  forest.each{|edge| puts edge}
+  #Compute back edges
+  bedges = graph.edges - forest
+  puts "Back edges:"
+  bedges.each{|edge| puts edge}
+end
+
+def main
+  edges = [
+    [1,2],[1,3],[1,4],[1,5],[1,6],[1,7],[1,8],
+    [2,5],[2,6],[2,8],
+    [3,4],[3,7],
+    [9,10],[9,13],
+    [10,11],[10,12],[10,13],
+    [11,12]
+  ]
+  run_example('Example 1 (undirected graph)', Graph.new(edges:edges))
+
+  diedges = [
+    [1,3],[1,5],
+    [2,1],
+    [3,2],
+    [4,3],
+    [5,4],[5,6],
+    [6,4],
+    [7,8],[7,9],
+    [9,6],[9,8]
+  ]
+
+  run_example('Example 2 (directed graph)', Digraph.new(edges:diedges))
+end
+
+main

data/examples/BipartMatching/bipart_matching.rb

@@ -0,0 +1,34 @@
+require 'graphsrb'
+require_relative '../MaxFlow/edmonds_karp'
+include Graphsrb
+
+
+module BipartiteMatching
+  def self.run(graph, part1)
+    init(graph, part1)
+    EdmondsKarp.run(@graph, @source, @target)
+  end
+
+  def self.init(graph, part1)
+    @graph = Digraph.new
+    max_id = graph.vertices.map{|v| v.id}.max
+
+    @source = Vertex.new(max_id + 1)
+    @target = Vertex.new(max_id + 2)
+
+    @graph.add_vertex(@source.id)
+    @graph.add_vertex(@target.id)
+
+    graph.edges.each do |e|
+      u,v = e.initial_vertex, e.terminal_vertex
+      u,v = v,u unless part1.include?(e.initial_vertex)
+
+      # source ==> u
+      @graph.add_edge(@source.id, u.id, weight:1)
+      # u ==> v
+      @graph.add_edge(u.id, v.id, weight:1)
+      # v ==> target
+      @graph.add_edge(v.id, @target.id, weight:1)
+    end
+  end
+end

data/examples/BipartMatching/main.rb

@@ -0,0 +1,58 @@
+require_relative 'bipart_matching'
+
+def run_example(example_title, graph, part1)
+  puts "------- #{example_title} ------ "
+  puts "The graph has #{graph.vertex_count} vertices and #{graph.edge_count} edges"
+  puts "Size of max bipartite matching: #{BipartiteMatching.run(graph, part1)}"
+end
+
+def main
+
+  edges = [
+    [1,2],
+    [3,2], [3,6],
+    [5,4], [5,6], [5,8],
+    [7,6],
+    [9,6]
+  ]
+  part1 = []
+  [1,3,5,7,9].each{|id| part1 << Vertex.new(id)}
+  run_example('Example 1', Graph.new(edges:edges), part1)
+
+
+  edges = [
+    [1,2],
+    [3,4],
+    [5,6],
+    [7,8]
+  ]
+  part1 = []
+  [1,3,5,7].each{|id| part1 << Vertex.new(id)}
+  run_example('Example 2', Graph.new(edges:edges), part1)
+
+  edges = [
+    [1,2],
+    [3,2],
+    [5,2],
+    [7,2]
+  ]
+  part1 = []
+  [1,3,5,7].each{|id| part1 << Vertex.new(id)}
+  run_example('Example 3', Graph.new(edges:edges), part1)
+
+
+  edges = [
+    [1,7],
+    [2,6],
+    [3,8],
+    [4,7],
+    [5,9],
+    [10,8]
+  ]
+  part1 = []
+  [1,2,3,4,5,10].each{|id| part1 << Vertex.new(id)}
+  run_example('Example 4', Graph.new(edges:edges), part1)
+
+end
+
+main

data/examples/EdgeConnectivity/econ.rb

@@ -0,0 +1,31 @@
+require 'graphsrb'
+require_relative '../MaxFlow/edmonds_karp'
+include Graphsrb
+
+# The edge-connectivity λ(G) of a connected graph G is the smallest number of edges
+# whose removal disconnects G.
+module EdgeConnectivity
+  MAX_INT = (2**(0.size * 8 -2) -1)
+
+  def self.run(graph)
+    init(graph)
+    min_maxflow = MAX_INT
+    u = graph.vertices.first
+
+    graph.vertices.each do |v|
+      next if u == v
+      maxflow = EdmondsKarp.run(@graph, u, v)
+      min_maxflow = maxflow if min_maxflow > maxflow
+    end
+
+    min_maxflow
+  end
+
+  def self.init(graph)
+    @graph = Digraph.new
+    graph.edges.each do |e|
+      @graph.add_edge(e.initial_vertex.id, e.terminal_vertex.id, weight:1)
+      @graph.add_edge(e.terminal_vertex.id, e.initial_vertex.id, weight:1)
+    end
+  end
+end