graphsrb 0.1.0

data/examples/EdgeConnectivity/main.rb

@@ -0,0 +1,34 @@
+require_relative 'econ'
+
+def run_example(example_title, graph)
+  puts "------- #{example_title} ------ "
+  puts "The graph has #{graph.vertex_count} vertices and #{graph.edge_count} edges"
+  puts "Edge connectivity is #{EdgeConnectivity.run(graph)}"
+end
+
+def main
+  edges = [
+    [1,2], [1,3], [1,5],
+    [2,4], [2,5], [2,6],
+    [3,4], [3,6],
+    [4,5], [4,6],
+    [5,6]
+  ]
+  run_example('Example 1', Graph.new(edges:edges))
+
+  edges = [
+    [1,2], [1,3],
+    [2,4],
+    [3,4],
+    [4,5],
+    [5,6], [5,6],
+    [6,7]
+  ]
+  run_example('Example 2', Graph.new(edges:edges))
+
+  edges = [[1,2],[2,3],[3,4],[4,1],[1,3],[4,2]]
+  run_example('Example 3', Graph.new(edges:edges))
+
+end
+
+main

data/examples/Euler/euler_tour.rb

@@ -0,0 +1,36 @@
+require 'graphsrb'
+include Graphsrb
+
+#Assumption: graph is nonempty connected undirected and all vertices have even degree
+module EulerTour
+  def self.run(graph)
+    init(graph)
+    dfs(graph.vertices.first)
+    return @circuit.reverse
+  end
+
+  def self.init(g)
+    @graph = g
+    @circuit = []
+    @stack = []
+  end
+
+  def self.dfs(v)
+    vertices = @graph.adjacent_vertices(v)
+    #If current vertex has no neighbors then
+    #add it to circuit, remove the last vertex from the stack
+    #and move to this vertex
+    if vertices.size == 0
+      @circuit << v
+      dfs(@stack.pop) unless @stack.empty?
+    else
+      #Add the vertex to the stack,
+      #take any of its neighbors u, remove the edge (v,u),
+      # and move to the vertex u.
+      @stack.push(v)
+      u = vertices.first
+      @graph.remove_edge(v, u)
+      dfs(u)
+    end
+  end
+end

data/examples/Euler/main.rb

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

data/examples/FundCircuits/fund_circuits.rb

@@ -0,0 +1,49 @@
+require 'graphsrb'
+require_relative '../PrimMST/prim'
+include Graphsrb
+
+# Consider a graph G and a spanning tree T of the graph G.
+# +Fundamental circuit+ is a circuit created by adding and edge to T.
+# The fundamental curcuits form a basis for all circuits in the graph.
+
+# Computes the set of fundamental circuits with
+# respect to a spanning tree
+module FundCircuits
+  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)}
+    cotree = graph.edges - edges
+
+    puts "Spanning tree:"
+    puts @spanning_tree.edges
+    puts "-"*25
+
+    fcs = []
+    #Computes fundamental circuits
+    #as sequences of vertices
+    cotree.each{|e| fcs << compute_path(e.initial_vertex, e.terminal_vertex)}
+    #Returns array of arrays of vertices
+    return fcs
+  end
+
+  def self.compute_path(from, to)
+    @target = to
+    @stack = [from]
+    @visited = []
+    dfs(from)
+    return @stack
+  end
+
+  def self.dfs(v)
+    @visited[v.id] = true
+    @spanning_tree.adjacent_vertices(v).each do |v|
+      @stack.push(v)
+      return true if v == @target
+      return true if !@visited[v.id] && dfs(v)
+      @stack.pop
+    end
+    false
+  end
+end

data/examples/FundCircuits/main.rb

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

data/examples/FundCutsets/fund_cutsets.rb

@@ -0,0 +1,50 @@
+require 'graphsrb'
+require_relative '../PrimMST/prim'
+include Graphsrb
+
+module FundCutset
+  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 fundamental cut-sets
+    fcs = []
+    edges.each do |e|
+      @spanning_tree.remove_edge(e.initial_vertex, e.terminal_vertex)
+      block1 = compute_block(e.initial_vertex)
+      block2 = compute_block(e.terminal_vertex)
+
+      cut_set = []
+      block1.each do |v|
+        block2.each do |u|
+          edge = graph.edge(v,u)
+          cut_set << edge if edge
+        end
+      end
+      @spanning_tree.add_edge(e.initial_vertex.id, e.terminal_vertex.id)
+      fcs << cut_set
+    end
+    return fcs
+  end
+
+  def self.compute_block(v)
+    @block = []
+    @visited = []
+    dfs(v)
+    return @block
+  end
+
+  def self.dfs(v)
+    @visited[v.id] = true
+    @block.push(v)
+    @spanning_tree.adjacent_vertices(v).each do |v|
+      dfs(v) unless @visited[v.id]
+    end
+  end
+end

data/examples/FundCutsets/main.rb

@@ -0,0 +1,26 @@
+require_relative 'fund_cutsets'
+
+def run_example(example_title, graph)
+  puts "------- #{example_title} ------ "
+  puts "The graph has #{graph.vertex_count} vertices and #{graph.edge_count} edges"
+  FundCutset.run(graph)
+end
+
+def main
+  edges = [
+    [1,2],[1,3],[1,5],
+    [2,4],[2,5],
+    [3,4],[3,5],
+    [4,5]
+  ]
+  fcs = run_example('Example 1', Graph.new(edges:edges))
+  puts "The fundamental cut set:"
+  fcs.each{|c| puts c; puts ''}
+
+  edges = [[1,2],[2,3],[3,4],[4,1]]
+  fcs = run_example('Example 2', Graph.new(edges:edges))
+  puts "The fundamental cut set:"
+  fcs.each{|c| puts c; puts ''}
+end
+
+main

data/examples/MaxFlow/edmonds_karp.rb

@@ -0,0 +1,91 @@
+require 'graphsrb'
+include Graphsrb
+
+module EdmondsKarp
+  MAX_INT = (2**(0.size * 8 -2) -1)
+
+  # Given undirected graph, source, and target
+  # computes maximum flow value between the source and target
+  def self.run(graph, s, t)
+    init(graph)
+    max_flow = 0
+    while true
+      min_val, vertices = find_path(s,t)
+      break if min_val.nil?
+      update_flows(vertices, min_val)
+      max_flow += min_val
+    end
+    max_flow
+  end
+
+  def self.init(graph)
+    @graph = graph
+
+    @flow = []
+    @graph.vertices.each{|v| @flow[v.id] = []}
+
+    @graph.vertices.each do |v|
+      @graph.adjacent_vertices(v).each do |u|
+        @flow[v.id][u.id] = 0
+      end
+    end
+  end
+
+  def self.find_path(s,t)
+    parent = []
+    queue = [s]
+    visited = []
+
+    parent[s.id] = nil
+    visited[s.id] = true
+
+    max_id = @graph.vertices.map{|v| v.id}.max
+    pushed_amount = Array.new(max_id, MAX_INT)
+
+    while !queue.empty?
+      v = queue.shift
+      break if v == t
+      vertices = @graph.adjacent_vertices(v)
+
+      vertices.each do |u|
+        cap = @graph.edge(v,u).weight
+        flow = @flow[v.id][u.id]
+        if !visited[u.id] && (cap - flow > 0)
+          queue.push(u)
+          visited[u.id] = true
+          parent[u.id] = v
+          pushed_amount[u.id] = [pushed_amount[v.id], cap - flow].min
+        end
+      end
+    end
+
+    return [nil, nil] if v != t
+
+    path = [t]
+    v = parent[t.id]
+    while true
+      path << v
+      break if v == s
+      v = parent[v.id]
+    end
+
+    [pushed_amount[t.id], path.reverse]
+  end
+
+  def self.update_flows(vertices, min_val)
+    (0...vertices.size-1).each do |i|
+      u,v = vertices[i], vertices[i+1]
+      @flow[u.id][v.id] += min_val
+    end
+  end
+
+  def self.print_flow
+    @graph.vertices.each do |v|
+      @graph.adjacent_vertices(v).each do |u|
+        cap = @graph.edge(v,u).weight
+        puts "(#{v.id})==#{@flow[v.id][u.id]}/#{cap}==>(#{u.id})"
+      end
+    end
+    puts "-"*45
+  end
+end

data/examples/MaxFlow/main.rb

@@ -0,0 +1,79 @@
+require_relative 'edmonds_karp'
+
+def run_example(example_title, graph, s, t)
+  puts "------- #{example_title} ------ "
+  puts "Max flow: #{EdmondsKarp.run(graph, s, t)}"
+  puts "Flow graph:"
+  EdmondsKarp.print_flow
+end
+
+def main
+  edges = [
+    [1,2,16], [1,3,13],
+    [2,4,12],
+    [3,2,4], [3,5,14],
+    [4,3,9], [4,6,20],
+    [5,4,7], [5,6,4]
+  ]
+  run_example("Example 1", Digraph.new(edges:edges), Vertex.new(1), Vertex.new(6))
+
+  edges = [
+    [1,2,3],[1,3,2],
+    [2,3,2],[2,4,4],
+    [3,6,6],
+    [4,5,3],[4,3,2],
+    [5,6,1]
+  ]
+  run_example("Example 2", Digraph.new(edges:edges), Vertex.new(1), Vertex.new(6))
+
+  edges = [
+    [1,2,10], [1,3,8],
+    [2,3,2], [2,4,5],
+    [3,5,10],
+    [4,6,7],
+    [5,4,8], [5,6,10]
+  ]
+  run_example("Example 3", Digraph.new(edges:edges), Vertex.new(1), Vertex.new(6))
+
+  edges = [
+    [1,2,10], [1,3,8],
+    [2,3,2], [2,4,8],
+    [3,4,6],[3,5,7],
+    [4,6,10],
+    [5,6,10]
+  ]
+  run_example("Example 4", Digraph.new(edges:edges), Vertex.new(1), Vertex.new(6))
+
+  edges = [
+    [1,2,3], [1,3,3], [1,4,4],
+    [2,5,2],
+    [3,2,10], [3,5,1],
+    [4,6,5],
+    [5,6,1], [5,7,2],
+    [6,7,5]
+  ]
+  run_example("Example 5", Digraph.new(edges:edges), Vertex.new(1), Vertex.new(7))
+
+  edges = [
+    [1,2,38], [1,3,1], [1,4,2],
+    [2,3,8],  [2,5,13],[2,6,10],
+    [3,6,26],
+    [4,8,27],
+    [5,3,2], [5,7,1],  [5,8,7],
+    [6,4,24], [6,7,8], [6,8,1],
+    [7,8,7]
+  ]
+  run_example("Example 6", Digraph.new(edges:edges), Vertex.new(1), Vertex.new(8))
+
+  edges = [
+    [1,2],
+    [2,9],
+    [3,2],
+    [5,2],
+    [7,2],
+    [8,1],[8,3],[8,5],[8,7]
+  ]
+  run_example("Example 7", Digraph.new(edges:edges), Vertex.new(8), Vertex.new(9))
+end
+
+main

data/examples/PrimMST/main.rb

@@ -0,0 +1,46 @@
+require_relative 'prim'
+
+def run_example(example_title, graph)
+  puts "------- #{example_title} ------ "
+  puts "The graph has #{graph.vertex_count} vertices and #{graph.edge_count} edges"
+  edges = PrimMST.run(graph)
+  puts "MST:"
+  edges.each{|e| puts e}
+  puts "MST value: #{edges.inject(0){|s, e| s + e.weight}}"
+end
+
+def main
+  edges = [
+    [1,2,19],[1,3,17],[1,5,5],
+    [2,4,13],[2,5,2], [2,6,7],
+    [3,4,3], [3,6,17],
+    [4,5,10],[4,6,14],
+    [5,6,9]
+  ]
+  run_example('Example 1', Graph.new(edges:edges))
+
+  edges = [
+    [1,2,1], [1,3,3], [1,4,4],
+    [2,3,2],
+    [3,4,5]
+  ]
+  run_example('Example 2', Graph.new(edges:edges))
+
+  edges = [
+    [1,2,1], [1,3,7],
+    [2,3,5], [2,4,3], [2,5,4],
+    [3,4,6],
+    [4,5,2]
+  ]
+  run_example('Example 3', Graph.new(edges:edges))
+
+  edges = [
+    [1,2,7], [1,4,6],
+    [2,3,6],
+    [4,2,9], [4,3,8]
+  ]
+  run_example('Example 4', Graph.new(edges:edges))
+
+end
+
+main