gratr19 0.4.4

data/lib/gratr/undirected_graph.rb

@@ -0,0 +1,153 @@
+#--
+# Copyright (c) 2006 Shawn Patrick Garbett
+# Copyright (c) 2002,2004,2005 by Horst Duchene
+# 
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+# 
+#     * Redistributions of source code must retain the above copyright notice(s),
+#       this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above copyright notice,
+#       this list of conditions and the following disclaimer in the documentation
+#       and/or other materials provided with the distribution.
+#     * Neither the name of the Shawn Garbett nor the names of its contributors
+#       may be used to endorse or promote products derived from this software
+#       without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#++
+
+
+require 'gratr/adjacency_graph'
+require 'gratr/search'
+require 'gratr/biconnected'
+require 'gratr/comparability'
+require 'set'
+
+module GRATR
+  class UndirectedGraph
+    include AdjacencyGraph
+    include Graph::Search
+    include Graph::Biconnected
+    include Graph::Comparability
+    
+    def initialize(*params)
+      raise ArgumentError if params.any? do |p| 
+       !(p.kind_of? GRATR::Graph or p.kind_of? Array)
+      end if self.class == GRATR::UndirectedGraph
+      super(*params)
+    end 
+
+    # UndirectedGraph is by definition undirected, always returns false
+    def directed?()  false; end
+      
+    # Redefine degree (default was sum)
+    def degree(v)    in_degree(v); end
+      
+    # A vertex of an undirected graph is balanced by definition
+    def balanced?(v)  true;  end
+
+    # UndirectedGraph uses Edge for the edge class.
+    def edge_class() @parallel_edges ? GRATR::MultiEdge : GRATR::Edge; end
+
+    def remove_edge!(u, v=nil)
+      unless u.kind_of? GRATR::Arc
+        raise ArgumentError if @parallel_edges 
+        u = edge_class[u,v]
+      end
+      super(u.reverse) unless u.source == u.target
+      super(u)
+    end
+    
+    # A triangulated graph is an undirected perfect graph that every cycle of length greater than
+    # three possesses a chord. They have also been called chordal, rigid circuit, monotone transitive,
+    # and perfect elimination graphs.
+    #
+    # Implementation taken from Golumbic's, "Algorithmic Graph Theory and
+    # Perfect Graphs" pg. 90
+    def triangulated?
+      a = Hash.new {|h,k| h[k]=Set.new}; sigma=lexicograph_bfs
+      inv_sigma = sigma.inject({}) {|acc,val| acc[val] = sigma.index(val); acc}
+      sigma[0..-2].each do |v|
+        x = adjacent(v).select {|w| inv_sigma[v] < inv_sigma[w] }
+        unless x.empty?
+           u = sigma[x.map {|y| inv_sigma[y]}.min]
+           a[u].merge(x - [u])
+        end
+        return false unless a[v].all? {|z| adjacent?(v,z)}
+      end
+      true
+    end
+    
+    def chromatic_number
+      return triangulated_chromatic_number if triangulated?
+      raise NotImplementedError    
+    end
+    
+    # An interval graph can have its vertices into one-to-one
+    # correspondence with a set of intervals F of a linearly ordered
+    # set (like the real line) such that two vertices are connected
+    # by an edge of G if and only if their corresponding intervals
+    # have nonempty intersection.
+    def interval?() triangulated? and complement.comparability?; end
+    
+    # A permutation diagram consists of n points on each of two parallel
+    # lines and n straight line segments matchin the points. The intersection
+    # graph of the line segments is called a permutation graph.
+    def permutation?() comparability? and complement.comparability?; end
+    
+    # An undirected graph is defined to be split if there is a partition
+    # V = S + K of its vertex set into a stable set S and a complete set K.    
+    def split?() triangulated? and complement.triangulated?; end
+    
+   private
+   # Implementation taken from Golumbic's, "Algorithmic Graph Theory and
+   # Perfect Graphs" pg. 99
+    def triangulated_chromatic_number
+      chi = 1; s= Hash.new {|h,k| h[k]=0}
+      sigma=lexicograph_bfs
+      inv_sigma = sigma.inject({}) {|acc,val| acc[val] = sigma.index(val); acc}
+      sigma.each do |v|
+        x = adjacent(v).select {|w| inv_sigma[v] < inv_sigma[w] }
+        unless x.empty?
+          u = sigma[x.map {|y| inv_sigma[y]}.min]
+          s[u] = [s[u], x.size-1].max
+          chi = [chi, x.size+1].max if s[v] < x.size
+        end
+      end; chi
+    end
+   
+  end # UndirectedGraph
+
+  # This is a UndirectedGraph that allows for parallel edges, but does not
+  # allow loops
+  class UndirectedPseudoGraph < UndirectedGraph
+    def initialize(*params)
+      raise ArgumentError if params.any? do |p| 
+       !(p.kind_of? Graph or p.kind_of? Array)
+      end
+      super(:parallel_edges, *params)
+    end 
+  end
+
+  # This is a UndirectedGraph that allows for parallel edges and loops
+  class UndirectedMultiGraph < UndirectedGraph
+    def initialize(*params)
+      raise ArgumentError if params.any? do |p| 
+       !(p.kind_of? Graph or p.kind_of? Array)
+      end
+      super(:parallel_edges, :loops, *params)
+    end 
+  end
+
+
+end # GRATR

data/lib/gratr/version.rb

@@ -0,0 +1,6 @@
+module GRATR
+  VERSION = "0.4.4"
+
+  # Deprecated.
+  GRATR_VERSION = VERSION
+end

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