gratr 0.4.2 → 0.4.3

data/README

@@ -269,6 +269,13 @@ Rick Bradley who reworked the library and added many graph theoretic constructs.
 The core interface is about to be updated to allow for cleaner dependency injects. Luke Kanies has also contributed
 several optimizations for speed and logged some bugs. This will result in a 0.5 release coming soon. 
 
+=== 0.4.3
+
+* Fixed bug in dot output dependency.
+* Changed method.call to send in a couple places.
+* Fixed bug in unconnected vertices for reversal. Ticket #7237
+* Fixed bugs in A* Search. Ticket #7250.
+
 === 0.4.2
 
 * Fixed bug in parallel edge adjacency detection.

data/lib/gratr.rb

@@ -31,3 +31,12 @@ require 'gratr/base'
 require 'gratr/digraph'
 require 'gratr/undirected_graph'
 require 'gratr/common'
+
+# Load priority queue classes
+begin
+  # Use installed Gem
+  require 'priority_queue'
+rescue LoadError # Use local copy
+  require 'priority-queue/lib/priority_queue/ruby_priority_queue'
+  PriorityQueue = RubyPriorityQueue
+end

data/lib/gratr/base.rb

@@ -26,7 +26,7 @@
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #++
 
-GRATR_VERSION = "0.4.2"
+GRATR_VERSION = "0.4.3"
 
 module GRATR
   class NoVertexError      < IndexError;   end

data/lib/gratr/digraph.rb

@@ -64,11 +64,13 @@ module GRATR
 
     # A digraph uses the Arc class for edges
     def edge_class() @parallel_edges ? GRATR::MultiArc : GRATR::Arc; end
-
+    
     # Reverse all edges in a graph
     def reversal
-      return new(self) unless directed?
-      edges.inject(self.class.new) {|a,e| a << e.reverse}
+      result = self.class.new
+      edges.inject(result) {|a,e| a << e.reverse}
+      vertices.each { |v| result.add_vertex!(v) unless result.vertex?(v) }
+      result
     end
 
     # Return true if the Graph is oriented.

data/lib/gratr/rdot.rb

@@ -7,6 +7,12 @@
 #
 # It also supports undirected edges.
 
+class Hash
+  def stringify_keys
+    inject({}) {|options, (key, value)| options[key.to_s] = value; options}
+  end
+end unless Hash.respond_to? :stringify_keys
+
 module DOT
     
   # These glogal vars are used to make nice graph source.

data/lib/gratr/search.rb

@@ -26,7 +26,6 @@
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #++
 
-
 module GRATR
   module Graph
     module Search
@@ -102,7 +101,7 @@ module GRATR
         roots       = []
         te = Proc.new {|e| predecessor[e.target] = e.source}
         rv = Proc.new {|v| roots << v}
-        method(routine).call :start => start, :tree_edge => te, :root_vertex => rv
+        send routine, :start => start, :tree_edge => te, :root_vertex => rv
         [predecessor, roots]
       end
       
@@ -120,7 +119,7 @@ module GRATR
         correct_tree = false
         te = Proc.new {|e| predecessor[e.target] = e.source if correct_tree}
         rv = Proc.new {|v| correct_tree = (v == start)}
-        method(routine).call :start => start, :tree_edge => te, :root_vertex => rv
+        send routine, :start => start, :tree_edge => te, :root_vertex => rv
         predecessor       
       end
       
@@ -252,44 +251,58 @@ module GRATR
       # Also see: http://en.wikipedia.org/wiki/A-star_search_algorithm
       #
       def astar(start, goal, func, options, &block)
-        options.instance_eval "def handle_vertex(sym,u) self[sym].call(u) if self[sym]; end"
-        options.instance_eval "def handle_edge(sym,u,v) self[sym].call(#{edge_class}[u,v]) if self[sym]; end"
-
+        options.instance_eval "def handle_callback(sym,u) self[sym].call(u) if self[sym]; end"
+         
+        # Initialize
         d = { start => 0 }
-        f = { start => func.call(start) }
-        color = {start => :gray}
-        p = Hash.new {|k| p[k] = k}
-        queue = [start]
+        
+        color = {start => :gray} # Open is :gray, Closed is :black
+        parent = Hash.new {|k| parent[k] = k}
+        f = {start => func.call(start)}
+        queue = PriorityQueue.new.push(start,f[start])
         block.call(start) if block
+        
+        # Process queue
         until queue.empty?
-          u = queue.pop
-          options.handle_vertex(:examine_vertex, u)
-          adjacent(u).each do |v|
-            e = edge_class[u,v]
-            options.handle_edge(:examine_edge, u, v)
+          u,dummy = queue.delete_min
+          options.handle_callback(:examine_vertex, u)
+
+          # Unravel solution if goal is reached.
+          if u == goal
+            solution = [goal]
+            while u != start
+              solution << parent[u]; u = parent[u]
+            end
+            return solution.reverse
+          end
+
+          adjacent(u, :type => :edges).each do |e|
+            v = e.source == u ? e.target : e.source
+            options.handle_callback(:examine_edge, e)
             w = cost(e, options[:weight])
             raise ArgumentError unless w
             if d[v].nil? or (w + d[u]) < d[v] 
-              options.handle_edge(:edge_relaxed, u, v)
+              options.handle_callback(:edge_relaxed, e)
               d[v] = w + d[u]
-              f[v] = d[v] + func.call(u)
-              p[v] = u
+              f[v] = d[v] + func.call(v)
+              parent[v] = u
               unless color[v] == :gray
-                options.handle_vertex(:black_target, v) if color[v] == :black
+                options.handle_callback(:black_target, v) if color[v] == :black
                 color[v] = :gray 
-                options.handle_vertex(:discover_vertex, v)
-                queue << v 
+                options.handle_callback(:discover_vertex, v)
+                queue.push v, f[v] 
                 block.call(v) if block
-                return [start]+queue if v == goal
               end
             else
-              options.handle_edge(:edge_not_relaxed, u, v)
+              options.handle_callback(:edge_not_relaxed, e)
             end
           end # adjacent(u)
           color[u] = :black
-          options.handle_vertex(:finish_vertex,u)
+          options.handle_callback(:finish_vertex,u)
         end # queue.empty?
+                
         nil # failure, on fall through
+      
       end # astar
     
       # Best first has all the same options as astar with func set to h(v) = 0.

data/lib/priority-queue/benchmark/dijkstra.rb

@@ -0,0 +1,171 @@
+$:.unshift "~/lib/ruby"
+require 'priority_queue/ruby_priority_queue'
+require 'priority_queue/poor_priority_queue'
+require 'priority_queue/c_priority_queue'
+require 'benchmark'
+
+class Node
+  attr_reader :neighbours, :id
+  
+  def initialize(id)
+    @neighbours = []
+    @id = id
+  end
+  
+  def inspect
+    to_s
+  end
+
+  def to_s
+    "(#{@id})"
+  end
+end
+
+# Build a graph by adding nodes with random connections
+
+# Return a random graph with an average degree of degree
+def make_graph(nodes, degree)
+  nodes = Array.new(nodes) { | i | Node.new(i.to_s) }
+  nodes.each do | n |
+    (degree / 2).times do 
+      true while (n1 = nodes[rand(nodes.length)]) == n
+      n.neighbours << nodes[rand(nodes.length)]
+      n1.neighbours << n
+      n.neighbours << n1
+    end
+  end
+end
+
+def draw_graph(nodes, out)
+  dot = [] << "graph g {"
+  nodes.each do | n1 |
+    dot << "N#{n1.id} [label='#{n1.id}'];"
+    n1.neighbours.each do | n2 |
+      dot << "N#{n1.id} -- N#{n2.id};" if n1.id <= n2.id
+    end
+  end
+  dot << "}"
+
+  #  system "echo '#{dot}' | neato -Gepsilon=0.001 -Goverlap=scale -Gsplines=true -Gsep=.4 -Tps -o #{out}"
+  system "echo '#{dot}' | neato -Gepsilon=0.05 -Goverlap=scale -Gsep=.4 -Tps -o #{out}"
+end
+
+def dijkstra(start_node, queue_klass)
+  # Priority Queue with unfinished nodes
+  active = queue_klass.new
+  # Distances for all nodes
+  distances = Hash.new { 1.0 / 0.0 }
+  # Parent pointers describing shortest paths for all nodes
+  parents = Hash.new
+
+  # Initialize with start node
+  active[start_node] = 0
+  until active.empty?
+    u, distance = active.delete_min
+    distances[u] = distance
+    d = distance + 1
+    u.neighbours.each do | v |
+      next unless d < distances[v] # we can't relax this one
+      active[v] = distances[v] = d
+      parents[v] = u
+    end    
+  end
+end
+
+srand
+
+sizes = Array.new(4) { | base | Array.new(9) { | mult | (mult+1) * 10**(base+2) } }.flatten
+degrees = [2, 4, 16]
+degrees = [4, 16]
+degrees = [16]
+queues = [  CPriorityQueue,  PoorPriorityQueue,  RubyPriorityQueue ]
+queues = [  CPriorityQueue,  RubyPriorityQueue ]
+
+max_time = 400
+ignore = Hash.new
+
+repeats = 5
+
+
+STDOUT.sync = true
+
+results = Hash.new { | h, k | h[k] = 
+  Hash.new { | h1, k1 | h1[k1] = Hash.new { 0 } 
+  } 
+}
+
+Benchmark.bm(30) do | b |
+  sizes.each do | size |
+    break if !ignore.empty? and ignore.values.inject(true) { | r, v | r and v }
+    puts
+    puts "Testing with graphs of size #{size}"
+    degrees.each do | degree |
+      repeats.times do | r |
+	nodes = make_graph(size, degree)
+	queues.each do | queue |      
+	  next if ignore[queue]
+	  GC.start
+	  results[queue][degree][size] += (b.report("#{queue}: #{size} (#{degree})") do dijkstra(nodes[1], queue) end).real
+	end
+      end
+      queues.each do | queue |      
+	ignore[queue] ||= ((results[queue][degree][size] / repeats) > max_time)
+      end
+    end
+
+    indices = queues.map { | q | degrees.map { | d | %&"#{q} (Graph of Degree: #{d})"& } }.flatten
+    File.open("results.csv", "wb") do | f |
+      f.puts "size\t" + indices.join("\t")
+      sizes.each do | size |
+	f.puts "#{size}\t" + queues.map { | q | degrees.map { | d | 
+	  (results[q][d].has_key?(size) and results[q][d][size] > 0.0) ? results[q][d][size] / repeats : "''" 
+	} }.join("\t")
+      end
+    end
+
+    File.open("results.gp", 'wb') do | f |
+      lines = []
+      indices.each_with_index do | t, i |
+	lines << "  'results.csv' using 1:#{i+2} with lines title #{t}"
+      end
+      f.puts "set term png"
+      f.puts "set out 'results.png'"
+      f.puts "set xlabel 'Number of nodes'"
+      f.puts "set ylabel 'Time in seconds (real)'"
+      f.puts "set logscale xy"
+      f.puts "set title 'Dijkstras Shortest Path Algorithm using different PQ Implementations'"
+      f.puts "plot \\"
+      f.puts lines.join(",\\\n")
+    end
+      system "gnuplot results.gp"
+    
+    queues.each do | q | 
+      File.open("result-#{q}.gp", 'wb') do | f |
+	lines = []
+	degrees.map { | d | %&"#{q} (Graph of Degree: #{d})"& }.flatten.each do | t |
+	  lines << "  'results.csv' using 1:#{indices.index(t)+2} with lines title #{t}"
+	end
+	f.puts "set term png"
+	f.puts "set out 'result-#{q}.png'"
+	f.puts "set xlabel 'Number of nodes'"
+	f.puts "set ylabel 'Time in seconds (real)'"
+	f.puts "set logscale xy"
+	f.puts "set title 'Dijkstras Shortest Path Algorithm on Networks of different degrees'"
+	f.puts "plot \\"
+	f.puts lines.join(",\\\n")
+      end
+      system "gnuplot result-#{q}.gp"
+    end
+  end
+end
+
+__END__
+
+nodes = make_graph(100, 4)
+draw_graph(nodes, "100-4.ps")
+nodes = make_graph(100, 10)
+draw_graph(nodes, "100-10.ps")
+nodes = make_graph(10, 10)
+draw_graph(nodes, "10-10.ps")
+nodes = make_graph(1000, 2)
+draw_graph(nodes, "1000-2.ps")

data/lib/priority-queue/compare_comments.rb

@@ -0,0 +1,49 @@
+c_file = File.read("ext/priority_queue/CPriorityQueue/priority_queue.c")
+rb_file = File.read("lib/priority_queue/ruby_priority_queue.rb")
+
+c_comments = Hash.new { "" }
+
+c_file.scan(%r(/\*(.*?)\*/\s*static\s+\w+\s*pq_(\w+)\(.*?\))m).each do | match |
+  c_comments[match[1]] = match[0].gsub(%r(\n\s*\* {0,1})m, "\n").strip
+end
+
+rb_comments = Hash.new { "" }
+
+rb_file.scan(%r(((?:\n\s*#[^\n]*)*)\s*def\s+(\w+))m).each do | match |
+  rb_comments[match[1]] = match[0].gsub(%r(\n\s*# {0,1})m, "\n").strip
+end
+
+add_comments = Hash.new
+
+(rb_comments.keys + c_comments.keys).uniq.each do | key |
+  #next if rb_comments[key].gsub(/\s+/m, " ") == c_comments[key].gsub(/\s+/m, " ")
+  if c_comments[key].empty?
+    add_comments[key] = rb_comments[key]
+  elsif rb_comments[key].empty?
+    add_comments[key] = c_comments[key]
+  elsif rb_comments[key] != c_comments[key]
+
+    puts key
+    puts "Ruby"
+    puts rb_comments[key]
+    puts "C"
+    puts c_comments[key]
+    puts
+    puts "Choose [c,r]"
+    1 until /^([cr])/ =~ gets
+    add_comments[key] = ($1 == "c" ? c_comments : rb_comments)[key]
+    puts "-" * 80
+    puts
+  else
+    add_comments[key] = rb_comments[key]
+  end
+
+end
+
+File.open("lib/priority_queue/ruby_priority_queue.new.rb", "wb") do | o |
+  o << 
+    rb_file.gsub(%r(((?:\n\s*#[^\n]*)*)(\s*def\s+(\w+)))m) do | match |
+      name, all =  $3, $2
+      "\n" + (add_comments[name].gsub(/^/, "#")) + all
+    end
+end

data/lib/priority-queue/ext/priority_queue/CPriorityQueue/extconf.rb

@@ -0,0 +1,2 @@
+require 'mkmf'
+create_makefile("CPriorityQueue")

data/lib/priority-queue/lib/priority_queue.rb

@@ -0,0 +1,14 @@
+# A priority queue implementation.
+# This extension contains two implementations, a c extension and a pure ruby
+# implementation. When the compiled extension can not be found, it falls back
+# to the pure ruby extension.
+#
+# See CPriorityQueue and RubyPriorityQueue for more information.
+
+begin
+  require 'priority_queue/CPriorityQueue'
+  PriorityQueue = CPriorityQueue
+rescue LoadError # C Version could not be found, try ruby version
+  require 'priority_queue/ruby_priority_queue'
+  PriorityQueue = RubyPriorityQueue
+end

data/lib/priority-queue/lib/priority_queue/c_priority_queue.rb

@@ -0,0 +1 @@
+require "priority_queue/CPriorityQueue"

data/lib/priority-queue/lib/priority_queue/poor_priority_queue.rb

@@ -0,0 +1,46 @@
+# A Poor mans Priority Queue. (Very inefficent but minimal implemention).
+class PoorPriorityQueue < Hash
+  def push(object, priority)
+    self[object] = priority
+  end
+
+  def min
+    return nil if self.empty?
+    min_k = self.keys.first
+    min_p = self[min_k]
+    self.each do | k, p |
+      min_k, min_p = k, p if p < min_p
+    end
+    [min_k, min_p]
+  end
+
+  def min_key
+    min[0] rescue nil
+  end
+  
+  def min_priority
+    min[1] rescue nil
+  end
+
+  def delete_min
+    return nil if self.empty?
+    min_k, min_p = *min
+    self.delete(min_k)
+    [min_k, min_p]
+  end
+
+  def delete_min_return_key
+    delete_min[0] rescue nil
+  end
+  
+  def delete_min_return_priority
+    delete_min[1] rescue nil
+  end
+
+  def delete(object)
+    return nil unless self.has_key?(object) 
+    result = [object, self[object]]
+    super
+    result
+  end
+end