jumoku 0.1.1 → 0.1.2

data/vendor/git/graphy/vendor/priority-queue/CHANGELOG

@@ -0,0 +1,33 @@
+0.1.2
+  * Repaired benchmark
+  * Added c_priority_queue wrapper, such that one can now require versions
+    explicitly using:
+        require "priority_queue/(c|ruby|poor)_priority_queue"
+  * Improved README
+
+0.1.1
+  * Removed debug cruft
+  * Added more documentation and examples
+  * Readme typo fixed
+  * I had the tests commented out
+  * Removed a bug when pushing twice onto the c priority queue (and added a test)
+
+0.1.0
+  * API changes
+  * Added lots of unit tests
+  * Restructured 
+  * Fallback to ruby version if c version is not available
+  * Added Efficent Pure Ruby Implementation (3 times slower than c version in
+    dijkstras algorithm)
+  * Added "Poor Mans Priority Queue" as a simple reference Implementation
+  * Minor improvements
+  * Added possibility to increase keys
+  * Minor bugs fixed
+  * Released as a .tar.gz (setup.rb)
+  * Released as a .gem (Anybody want to improve the distribution or point me to
+    some information on how to relase as .tar.gz and as .gem without too much
+    ado)
+
+0.0.0:
+  * First c-implementation
+  * Experimental Release

data/vendor/git/graphy/vendor/priority-queue/Makefile

@@ -0,0 +1,140 @@
+
+SHELL = /bin/sh
+
+#### Start of system configuration section. ####
+
+srcdir = .
+topdir = /usr/lib/ruby/1.8/i486-linux
+hdrdir = $(topdir)
+VPATH = $(srcdir):$(topdir):$(hdrdir)
+prefix = $(DESTDIR)/usr
+exec_prefix = $(prefix)
+sitedir = $(DESTDIR)/usr/local/lib/site_ruby
+rubylibdir = $(libdir)/ruby/$(ruby_version)
+archdir = $(rubylibdir)/$(arch)
+sbindir = $(exec_prefix)/sbin
+datadir = $(prefix)/share
+includedir = $(prefix)/include
+infodir = $(prefix)/info
+sysconfdir = $(DESTDIR)/etc
+mandir = $(datadir)/man
+libdir = $(exec_prefix)/lib
+sharedstatedir = $(prefix)/com
+oldincludedir = $(DESTDIR)/usr/include
+sitearchdir = $(sitelibdir)/$(sitearch)
+bindir = $(exec_prefix)/bin
+localstatedir = $(DESTDIR)/var
+sitelibdir = $(sitedir)/$(ruby_version)
+libexecdir = $(exec_prefix)/libexec
+
+CC = gcc
+LIBRUBY = $(LIBRUBY_SO)
+LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a
+LIBRUBYARG_SHARED = -l$(RUBY_SO_NAME)
+LIBRUBYARG_STATIC = -l$(RUBY_SO_NAME)-static
+
+CFLAGS   =  -fPIC -Wall -g -O2  -fPIC 
+CPPFLAGS = -I. -I$(topdir) -I$(hdrdir) -I$(srcdir)  
+CXXFLAGS = $(CFLAGS) 
+DLDFLAGS =   
+LDSHARED = $(CC) -shared
+AR = ar
+EXEEXT = 
+
+RUBY_INSTALL_NAME = ruby1.8
+RUBY_SO_NAME = ruby1.8
+arch = i486-linux
+sitearch = i486-linux
+ruby_version = 1.8
+ruby = /usr/bin/ruby1.8
+RUBY = $(ruby)
+RM = rm -f
+MAKEDIRS = mkdir -p
+INSTALL = /usr/bin/install -c
+INSTALL_PROG = $(INSTALL) -m 0755
+INSTALL_DATA = $(INSTALL) -m 644
+COPY = cp
+
+#### End of system configuration section. ####
+
+preload = 
+
+libpath = $(libdir)
+LIBPATH =  -L"$(libdir)"
+DEFFILE = 
+
+CLEANFILES = 
+DISTCLEANFILES = 
+
+extout = 
+extout_prefix = 
+target_prefix = 
+LOCAL_LIBS = 
+LIBS = $(LIBRUBYARG_SHARED)  -lpthread -ldl -lcrypt -lm   -lc
+SRCS = priority_queue.c
+OBJS = priority_queue.o
+TARGET = priority_queue
+DLLIB = $(TARGET).so
+STATIC_LIB = 
+
+RUBYCOMMONDIR = $(sitedir)$(target_prefix)
+RUBYLIBDIR    = $(sitelibdir)$(target_prefix)
+RUBYARCHDIR   = $(sitearchdir)$(target_prefix)
+
+TARGET_SO     = $(DLLIB)
+CLEANLIBS     = $(TARGET).so $(TARGET).il? $(TARGET).tds $(TARGET).map
+CLEANOBJS     = *.o *.a *.s[ol] *.pdb *.exp *.bak
+
+all:		$(DLLIB)
+static:		$(STATIC_LIB)
+
+clean:
+		@-$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES)
+
+distclean:	clean
+		@-$(RM) Makefile extconf.h conftest.* mkmf.log
+		@-$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES)
+
+realclean:	distclean
+install: install-so install-rb
+
+install-so: $(RUBYARCHDIR)
+install-so: $(RUBYARCHDIR)/$(DLLIB)
+$(RUBYARCHDIR)/$(DLLIB): $(DLLIB)
+	$(INSTALL_PROG) $(DLLIB) $(RUBYARCHDIR)
+install-rb: pre-install-rb install-rb-default
+install-rb-default: pre-install-rb-default
+pre-install-rb pre-install-rb-default: $(RUBYLIBDIR)
+$(RUBYARCHDIR):
+	$(MAKEDIRS) $@
+$(RUBYLIBDIR):
+	$(MAKEDIRS) $@
+
+site-install: site-install-so site-install-rb
+site-install-so: install-so
+site-install-rb: install-rb
+
+.SUFFIXES: .c .m .cc .cxx .cpp .C .o
+
+.cc.o:
+	$(CXX) $(CXXFLAGS) $(CPPFLAGS) -c $<
+
+.cxx.o:
+	$(CXX) $(CXXFLAGS) $(CPPFLAGS) -c $<
+
+.cpp.o:
+	$(CXX) $(CXXFLAGS) $(CPPFLAGS) -c $<
+
+.C.o:
+	$(CXX) $(CXXFLAGS) $(CPPFLAGS) -c $<
+
+.c.o:
+	$(CC) $(CFLAGS) $(CPPFLAGS) -c $<
+
+$(DLLIB): $(OBJS)
+	@-$(RM) $@
+	$(LDSHARED) $(DLDFLAGS) $(LIBPATH) -o $@ $(OBJS) $(LOCAL_LIBS) $(LIBS)
+
+
+
+$(OBJS): ruby.h defines.h

data/vendor/git/graphy/vendor/priority-queue/README

@@ -0,0 +1,133 @@
+# Ruby extension implementing a priority queue
+
+## Description
+This is a fibonacci-heap priority-queue implementation. That means
+
+    insert:                      O(1)
+    decrease_priority: Amortized O(1)
+    delete_min:        Amortized O(log n)
+
+This project is different from K. Kodamas PQueue in that it allows a decrease
+key operation.  That makes PriorityQueue usable for algorithms like dijkstras
+shortest path algorithm, while PQueue is more suitable for Heapsort and the
+like.
+
+## Legal stuff
+(c) 2005 Brian Schr�der
+
+Please submit bugreports to priority_queue@brian-schroeder.de
+
+This extension is under the same license as ruby.
+
+Do not hold me reliable for anything that happens to you, your programs or
+anything else because of this extension. It worked for me, but there is no
+guarantee it will work for you.
+
+## Requirements
+ * Ruby 1.8
+ * c Compiler  
+
+## Installation
+
+### Installing from source
+
+De-compress archive and enter its top directory.
+Then type:
+
+   ($ su)
+    # ruby setup.rb
+
+These simple step installs this program under the default
+location of Ruby libraries.  You can also install files into
+your favorite directory by supplying setup.rb some options.
+Try "ruby setup.rb --help".
+
+### Installing a ruby gem
+
+   ($ su)
+    # gem install PriorityQueue
+
+## Usage
+
+In this priority queue implementation the queue behaves similarly to a hash
+that maps objects onto priorities.
+
+### Hash Interface
+    require 'priority_queue'
+
+    q = PriorityQueue.new
+    q["node1"] = 0
+    q["node2"] = 1
+    q.min #=> "node1"
+    q[q.min] #=> 0
+    q.min_value #=> 0
+
+    q["node2"] = -1
+    q.delete_min #=> "node2", 1
+    q["node2"] #= nil
+    q["node3"] = 1
+
+    q.delete("node3") #=> "node3", 1
+    q.delete("node2") #=> nil
+
+
+### Queue Interface
+    require 'priority_queue'
+
+    q = PriorityQueue.new
+    q.push "node1", 0 
+    q.push "node2", 1
+
+    q.min #=> "node1"
+
+    q.decrease_priority("node2", -1)
+
+    q.pop_min #=> "node2"
+    q.min     #=> "node1"
+
+for more exmples look into the documentation, the unit tests and the benchmark
+suite.
+
+### Dijkstras shortest path algorithm
+    def dijkstra(start_node)
+      # Nodes that may have neighbours wich can be relaxed further
+      active = PriorityQueue.new         
+      # Best distances found so far
+      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
+      parents
+    end
+
+## Performance
+The benchmark directory contains an example where a random graph is created and
+the shortests paths from a random node in this graph to all other nodes are
+calculated with dijkstras shortests path algorithm. The algorithm is used to
+compare the three different priority queue implementations in this package.
+
+  * PoorPriorityQueue: A minimal priority queue implementation wich has
+    delete_min in O(n).
+  * RubyPriorityQueue: An efficent implementation in pure ruby.
+  * CPriorityQueue: The same efficent implementation as a c extension.
+  
+The results are shown here
+
+![Runtime for graphs of up to 8_000 Nodes](doc/compare_small.png "Runtime for graphs of up to 8_000 Nodes")
+
+![Runtime for graphs of up to 600_000 Nodes](doc/compare_big.png "Runtime for graphs of up to 600_000 Nodes")
+
+## Todo
+  * Only write documentation once

data/vendor/git/graphy/vendor/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")