PriorityQueue 0.1.0 → 0.1.1

data/CHANGELOG

@@ -1,3 +1,10 @@
+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

data/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/README

@@ -1,7 +1,7 @@
 # Ruby extension implementing a priority queue
 
 ## Description
-This is a fibonacy heap priority queue implementation. That means
+This is a fibonacci-heap priority-queue implementation. That means
 
 insert:                      O(1)
 decrease_priority: Amortized O(1)

data/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/ext/priority_queue/priority_queue.c

@@ -3,7 +3,7 @@
  *
  * Ruby extension implementing a priority queue
  * 
- * This is a fibonacy heap priority queue implementation.
+ * This is a fibonacci heap priority queue implementation.
  *
  * (c) 2005 Brian Schr�der
  * 
@@ -514,8 +514,20 @@ VALUE pq_push(VALUE self, VALUE object, VALUE priority) {
   return self;
 }
 
-/*
- * Return the pair [object, priority] with minimal priority
+/* call-seq:
+ *     min -> [object, priority]
+ *     
+ * Return the pair [object, priority] with minimal priority or nil when the
+ * queue is empty.
+ *
+ *     q = PriorityQueue.new
+ *     q["a"] = 10
+ *     q["b"] = 20
+ *     q.min          #=> ["a", 10]
+ *     q.delete_min   #=> ["a", 10]
+ *     q.min          #=> ["b", 20]
+ *     q.delete_min   #=> ["b", 20]
+ *     q.min          #=> nil
  */
 static
 VALUE pq_min(VALUE self) {
@@ -528,8 +540,19 @@ VALUE pq_min(VALUE self) {
     return Qnil;
 }
 
-/*
- * Return the key that has the minimal priority
+/* call-seq:
+ *     min_key -> object
+ *     
+ * Return the key that has the minimal priority or nil when the queue is empty.
+ *
+ *     q = PriorityQueue.new
+ *     q["a"] = 10
+ *     q["b"] = 20
+ *     q.min_key      #=> "a"
+ *     q.delete_min   #=> ["a", 10]
+ *     q.min_key      #=> "b"
+ *     q.delete_min   #=> ["b", 20]
+ *     q.min_key      #=> nil
  */
 static
 VALUE pq_min_key(VALUE self) {
@@ -542,8 +565,19 @@ VALUE pq_min_key(VALUE self) {
     return Qnil;
 }
 
-/*
- * Return the minimal priority
+/* call-seq:
+ *     min_priority -> priority
+ *
+ * Return the minimal priority or nil when the queue is empty.
+ *
+ *     q = PriorityQueue.new
+ *     q["a"] = 10
+ *     q["b"] = 20
+ *     q.min_priority #=> 10
+ *     q.delete_min   #=> ["a", 10]
+ *     q.min_priority #=> 20
+ *     q.delete_min   #=> ["b", 20]
+ *     q.min_priority #=> nil
  */
 static
 VALUE pq_min_priority(VALUE self) {
@@ -556,8 +590,17 @@ VALUE pq_min_priority(VALUE self) {
     return Qnil;
 }
 
-/*
+/* call-seq:
+ *    delete_min -> [key, priority]
+ * 
  * Delete key with minimal priority and return [key, priority]
+ *
+ *    q = PriorityQueue.new
+ *    q["a"] = 1
+ *    q["b"] = 0
+ *    q.delete_min #=> ["b", 0]
+ *    q.delete_min #=> ["a", 1]
+ *    q.delete_min #=> nil
  */
 static
 VALUE pq_delete_min(VALUE self) {
@@ -574,8 +617,17 @@ VALUE pq_delete_min(VALUE self) {
   }
 }
 
-/*
+/* call-seq:
+ *    delete_min_return_key -> key
+ * 
  * Delete key with minimal priority and return the key
+ *
+ *    q = PriorityQueue.new
+ *    q["a"] = 1
+ *    q["b"] = 0
+ *    q.delete_min_return_key #=> "b"
+ *    q.delete_min_return_key #=> "a"
+ *    q.delete_min_return_key #=> nil
  */
 static
 VALUE pq_delete_min_return_key(VALUE self) {
@@ -593,7 +645,17 @@ VALUE pq_delete_min_return_key(VALUE self) {
 }
 
 /*
+ * call-seq:
+ *   delete_min_return_priority -> priority
+ *
  * Delete key with minimal priority and return the priority value
+ *
+ *    q = PriorityQueue.new
+ *    q["a"] = 1
+ *    q["b"] = 0
+ *    q.delete_min_return_priority #=> 0
+ *    q.delete_min_return_priority #=> 1
+ *    q.delete_min_return_priority #=> nil
  */
 static
 VALUE pq_delete_min_return_priority(VALUE self) {
@@ -612,7 +674,9 @@ VALUE pq_delete_min_return_priority(VALUE self) {
 
 /*
  * call-seq:
- *     queue[key] = priority
+ *     [key] = priority
+ *     change_priority(key, priority)
+ *     push(key, priority)
  *
  * Set the priority of a key.
  *
@@ -641,7 +705,7 @@ VALUE pq_change_priority(VALUE self, VALUE object, VALUE priority) {
 
 /*
  * call-seq:
- *     queue[key] -> priority
+ *     [key] -> priority
  *
  * Return the priority of a key or nil if the key is not in the queue.
  *
@@ -663,6 +727,9 @@ VALUE pq_get_priority(VALUE self, VALUE object) {
 }
 
 /*
+ * call-seq:
+ *     has_key? key -> boolean
+ *     
  * Return false if the key is not in the queue, true otherwise.
  *
  *     q = PriorityQueue.new
@@ -678,7 +745,9 @@ VALUE pq_has_key(VALUE self, VALUE object) {
   
   return NIL_P(node_pointer) ? Qfalse : Qtrue;
 }
-/*
+/* call-seq:
+ *     length -> Fixnum
+ * 
  * Returns the number of elements of the queue.
  * 
  *     q = PriorityQueue.new
@@ -694,13 +763,17 @@ VALUE pq_length(VALUE self) {
 }
 
 /*
+/* call-seq:
+ *    delete(key) -> [key, priority]
+ *    delete(key) -> nil
+ * 
  * Delete a key from the priority queue. Returns nil when the key was not in
  * the queue and [key, priority] otherwise.
  * 
  *     q = PriorityQueue.new
  *     (0..10).each do | i | q[i.to_s] = i end
- *     q.delete(5) #=> ["5", 5]
- *     q.delete(5) #=> nil
+ *     q.delete(5)                               #=> ["5", 5]
+ *     q.delete(5)                               #=> nil
  */
 static
 VALUE pq_delete(VALUE self, VALUE object) {
@@ -762,7 +835,7 @@ static
 VALUE pq_to_dot(VALUE self) {
   priority_queue* q = get_pq_from_value(self);
 
-  VALUE result_string = rb_str_new2("digraph fibonaccy_heap {\n");
+  VALUE result_string = rb_str_new2("digraph fibonacci_heap {\n");
   if (q->rootlist) {
     priority_node* n1 = q->rootlist;
     do {    
@@ -789,9 +862,10 @@ void pq_each_helper(priority_queue *q, priority_node *n, void *args) {
 };
 
 /*
- * Call the given block with each key, priority pair in the queue
+ * Call the given block with each [key, priority] pair in the queue
  *
- * Beware: Changing the queue in the block may lead to unwanted behaviour and even infinite loops.
+ * Beware: Changing the queue in the block may lead to unwanted behaviour and
+ * even infinite loops.
  */
 static
 VALUE pq_each(VALUE self) {
@@ -806,7 +880,7 @@ VALUE pq_insert_node(VALUE node, VALUE queue) {
 }
 
 static
-VALUE pq_init_copy(VALUE copy, VALUE orig) {
+VALUE pq_initialize_copy(VALUE copy, VALUE orig) {
   if (copy == orig)
     return copy;
 
@@ -851,14 +925,14 @@ void Init_CPriorityQueue() {
 
   rb_define_alloc_func(cPriorityQueue, pq_alloc);
   rb_define_method(cPriorityQueue, "initialize", pq_init, 0);
-  rb_define_method(cPriorityQueue, "initialize_copy", pq_init_copy, 1);
-  rb_define_method(cPriorityQueue, "push", pq_push, 2);
+  rb_define_method(cPriorityQueue, "initialize_copy", pq_initialize_copy, 1);
   rb_define_method(cPriorityQueue, "min", pq_min, 0);
   rb_define_method(cPriorityQueue, "min_key", pq_min_key, 0);
   rb_define_method(cPriorityQueue, "min_priority", pq_min_priority, 0);
   rb_define_method(cPriorityQueue, "delete_min", pq_delete_min, 0);
   rb_define_method(cPriorityQueue, "delete_min_return_key", pq_delete_min_return_key, 0);
   rb_define_method(cPriorityQueue, "delete_min_return_priority", pq_delete_min_return_priority, 0);
+  rb_define_method(cPriorityQueue, "push", pq_change_priority, 2);
   rb_define_method(cPriorityQueue, "change_priority", pq_change_priority, 2);
   rb_define_method(cPriorityQueue, "[]=", pq_change_priority, 2);
   rb_define_method(cPriorityQueue, "priority", pq_get_priority, 1);

data/lib/priority_queue/ruby_priority_queue.rb

@@ -1,11 +1,11 @@
 # Pure ruby Priority Queue
-$stdout.sync = true
-$stderr.sync = true
-
 class RubyPriorityQueue
 
+  include Enumerable
+
   private
 
+  #
   def link_nodes(b1, b2)
     return link_nodes(b2, b1) if b2.priority < b1.priority
 
@@ -66,8 +66,8 @@ class RubyPriorityQueue
 
     return self
   end
-
-  # Does not change length priority
+  
+  # Does not change length
   def insert_tree(tree)
     if @rootlist == nil
       @rootlist = @min = tree
@@ -113,7 +113,7 @@ class RubyPriorityQueue
       raise "Child is neighbour" if c == self.left
       @child = c
     end
-
+    
     def to_dot(only_down = false, known_nodes = [])
       p known_nodes.map { | n | n.dot_id }
       p self.dot_id
@@ -151,15 +151,24 @@ class RubyPriorityQueue
 
   public
 
+  # Returns the number of elements of the queue.
+  # 
+  #    q = PriorityQueue.new
+  #    q.length #=> 0
+  #    q[0] = 1
+  #    q.length #=> 1
   attr_reader :length
 
+  # Create a new, empty PriorityQueue
   def initialize
     @nodes = Hash.new
     @rootlist = nil
     @min = nil
     @length = 0
   end
-
+  
+  # Print a priority queue as a dot-graph. The output can be fed to dot from the
+  # vizgraph suite to create a tree depicting the internal datastructure.
   def to_dot
     r = ["digraph fibheap {"]
     #r << @rootlist.to_dot.join("\n") if @rootlist
@@ -175,11 +184,26 @@ class RubyPriorityQueue
     r
   end
 
+  # Call dot and gv displaying the datstructure
   def display_dot
     puts to_dot
     system "echo '#{to_dot}' | twopi -Tps -Groot=ROOT -Goverlap=false> /tmp/dotfile.ps; gv /tmp/dotfile.ps"
   end
-
+  
+  # call-seq:
+  #     [key] = priority
+  #     change_priority(key, priority)
+  #     push(key, priority)
+  # 
+  # Set the priority of a key.
+  #
+  #     q = PriorityQueue.new
+  #     q["car"] = 50
+  #     q["train"] = 50
+  #     q["bike"] = 10
+  #     q.min #=> ["bike", 10]
+  #     q["car"] = 0
+  #     q.min #=> ["car", 0]
   def change_priority(key, priority)
     return push(key, priority) unless @nodes[key]
 
@@ -202,7 +226,8 @@ class RubyPriorityQueue
 
     self
   end
-
+  
+  # Add an object to the queue.
   def push(key, priority)    
     return change_priority(key, priority) if @nodes[key]
     @nodes[key] = node = Node.new(key, priority)
@@ -219,49 +244,113 @@ class RubyPriorityQueue
     @length += 1
     self
   end
-
+  
+  # Returns true if the array is empty, false otherwise.
   def empty?
     @rootlist.nil?
   end
 
+  # call-seq:
+  #     [key] -> priority
+  #
+  # Return the priority of a key or nil if the key is not in the queue.
+  #
+  #     q = PriorityQueue.new
+  #     (0..10).each do | i | q[i.to_s] = i end
+  #     q["5"] #=> 5
+  #     q[5] #=> nil
   def [](key)
     @nodes[key] and @nodes[key].priority
   end
 
+  # call-seq:
+  #     has_key? key -> boolean
+  #     
+  # Return false if the key is not in the queue, true otherwise.
+  #
+  #     q = PriorityQueue.new
+  #     (0..10).each do | i | q[i.to_s] = i end
+  #     q.has_key("5") #=> true 
+  #     q.has_key(5)   #=> false
   def has_key?(key)
     @nodes.has_key?(key)
   end
 
   alias :[]= :push
 
+  # Call the given block with each [key, priority] pair in the queue
+  #
+  # Beware: Changing the queue in the block may lead to unwanted behaviour and
+  # even infinite loops.
   def each
     @nodes.each do | key, node |
       yield(key, node.priority)
     end
   end
 
-  include Enumerable
-
+  # call-seq:
+  #     min -> [object, priority]
+  #    
+  # Return the pair [object, priority] with minimal priority or nil when the
+  # queue is empty.
+  #
+  #     q = PriorityQueue.new
+  #     q["a"] = 10
+  #     q["b"] = 20
+  #     q.min          #=> ["a", 10]
+  #     q.delete_min   #=> ["a", 10]
+  #     q.min          #=> ["b", 20]
+  #     q.delete_min   #=> ["b", 20]
+  #     q.min          #=> nil
   def min
     [@min.key, @min.priority] rescue nil
   end
-
+  
+  # call-seq:
+  #     min_key -> object
+  #    
+  # Return the key that has the minimal priority or nil when the queue is empty.
+  #
+  #     q = PriorityQueue.new
+  #     q["a"] = 10
+  #     q["b"] = 20
+  #     q.min_key      #=> "a"
+  #     q.delete_min   #=> ["a", 10]
+  #     q.min_key      #=> "b"
+  #     q.delete_min   #=> ["b", 20]
+  #     q.min_key      #=> nil
   def min_key    
     @min.key rescue nil
   end
-
+  
+  # call-seq:
+  #     min_priority -> priority
+  #
+  # Return the minimal priority or nil when the queue is empty.
+  #
+  #     q = PriorityQueue.new
+  #     q["a"] = 10
+  #     q["b"] = 20
+  #     q.min_priority #=> 10
+  #     q.delete_min   #=> ["a", 10]
+  #     q.min_priority #=> 20
+  #     q.delete_min   #=> ["b", 20]
+  #     q.min_priority #=> nil
   def min_priority
     @min.priority rescue nil
   end
-
-  def delete_min_return_key
-    delete_min[0] rescue nil
-  end
-
-  def delete_min_return_priority
-    delete_min[1] rescue nil
-  end
-
+  
+  # call-seq:
+  #     delete(key) -> [key, priority]
+  #     delete(key) -> nil
+  #
+  # Delete a key from the priority queue. Returns nil when the key was not in
+  # the queue and [key, priority] otherwise.
+  #
+  #     q = PriorityQueue.new
+  #     (0..10).each do | i | q[i.to_s] = i end
+  #     q.delete(5)                              #=> ["5", 5]
+  #     q.delete(5)                              #=> nil
   def delete(key)
     return nil unless n = @nodes.delete(key)
 
@@ -298,6 +387,47 @@ class RubyPriorityQueue
     return [n.key, n.priority]
   end
 
+  # call-seq:
+  #    delete_min_return_key -> key
+  #    
+  # Delete key with minimal priority and return the key
+  #
+  #    q = PriorityQueue.new
+  #    q["a"] = 1
+  #    q["b"] = 0
+  #    q.delete_min_return_key #=> "b"
+  #    q.delete_min_return_key #=> "a"
+  #    q.delete_min_return_key #=> nil
+  def delete_min_return_key
+    delete_min[0] rescue nil
+  end
+  
+  # call-seq:
+  #    delete_min_return_priority -> priority
+  #    
+  # Delete key with minimal priority and return the priority value
+  #
+  #    q = PriorityQueue.new
+  #    q["a"] = 1
+  #    q["b"] = 0
+  #    q.delete_min_return_priority #=> 0
+  #    q.delete_min_return_priority #=> 1
+  #    q.delete_min_return_priority #=> nil
+  def delete_min_return_priority
+    delete_min[1] rescue nil
+  end
+
+  # call-seq:
+  #    delete_min -> [key, priority]
+  #    
+  # Delete key with minimal priority and return [key, priority]
+  #
+  #    q = PriorityQueue.new
+  #    q["a"] = 1
+  #    q["b"] = 0
+  #    q.delete_min #=> ["b", 0]
+  #    q.delete_min #=> ["a", 1]
+  #    q.delete_min #=> nil
   def delete_min
     return nil if self.empty?
     result = self.min
@@ -351,7 +481,8 @@ class RubyPriorityQueue
 
     result
   end
-
+  
+  # Returns a string representation of the priority queue.
   def inspect
     "<PriorityQueue: #{@nodes.map{|(_, n)| [n.key, n.priority]}.sort_by{|(_,p)|p}.inspect}>"
   end

data/t.rb

@@ -0,0 +1,18 @@
+class T
+  def initialize
+    begin
+      raise "T"
+    rescue => e
+      e1 = e
+    end
+    begin
+      raise "T"
+    rescue => e
+      e2 = e
+    end
+    r1 = 12 rescue Object => e
+    p [e1, e2, e, r1]
+  end
+end
+
+T.new

data/test/priority_queue_test.rb

@@ -93,6 +93,22 @@ module PriorityQueueTest
     assert_equal(false, @q.empty?, "Filled queue should return false on empty?")
   end
 
+  def test_push
+    20.times do | i |
+      @q.push i, i+10
+    end
+
+    20.times do | i |
+      @q.push i, i
+    end
+    
+    20.times do | i |
+      assert_equal([i, i], @q.delete_min)
+    end
+
+    assert_equal(nil, @q.delete_min)
+  end
+
   def test_push_pop
     20.times do | i |
       @q.push i, i
@@ -233,9 +249,6 @@ module PriorityQueueTest
     end
     qq = @q.dup
     until @q.empty?
-      puts "--"
-      puts @q.inspect
-      puts qq.inspect
       assert_equal(@q.delete_min, qq.delete_min)
     end
   end
@@ -251,7 +264,7 @@ module PriorityQueueTest
   extend self
 end
 
-class CPriorityQueueTest #< Test::Unit::TestCase
+class CPriorityQueueTest < Test::Unit::TestCase
   include PriorityQueueTest
 
   def setup
@@ -264,7 +277,7 @@ class CPriorityQueueTest #< Test::Unit::TestCase
     end
     @q.delete_min
     assert_equal(
-    ['digraph fibonaccy_heap {',
+    ['digraph fibonacci_heap {',
     '  NODE [label="N1 (1)",shape=box];',
     '    NODE [label="N3 (3)",shape=box];',
     '      NODE [label="N4 (4)",shape=box];',
@@ -277,7 +290,7 @@ class CPriorityQueueTest #< Test::Unit::TestCase
 
 end
 
-class PoorPriorityQueueTest #< Test::Unit::TestCase
+class PoorPriorityQueueTest < Test::Unit::TestCase
   include PriorityQueueTest
 
   def setup

metadata

@@ -1,78 +1,67 @@
---- !ruby/object:Gem::Specification 
+!ruby/object:Gem::Specification 
 rubygems_version: 0.8.11
 specification_version: 1
 name: PriorityQueue
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.1.1
 date: 2005-10-26 00:00:00 +02:00
-summary: This is a fibonacy heap priority queue implementation
+summary: This is a fibonacci-heap priority-queue implementation
 require_paths: 
-  - lib
-  - lib
-  - ext
+- lib
+- lib
+- ext
 email: priority_queue@brian-schroeder.de
 homepage: http://ruby.brian-schroeder.de/priority_queue
 rubyforge_project: 
-description: "This is a fibonacy 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."
+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."
 autorequire: priority_queue.rb
 default_executable: 
 bindir: bin
 has_rdoc: true
 required_ruby_version: !ruby/object:Gem::Version::Requirement 
   requirements: 
-    - 
-      - ">"
-      - !ruby/object:Gem::Version 
-        version: 0.0.0
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
   version: 
 platform: ruby
 signing_key: 
 cert_chain: 
 authors: 
-  - Brian Schroeder
+- Brian Schroeder
 files: 
-  - README
-  - test.rb
-  - CHANGELOG
-  - setup.rb
-  - doc
-  - ext
-  - lib
-  - test
-  - benchmark
-  - doc/result-PriorityQueue.png
-  - doc/results.png
-  - doc/result-PoorPriorityQueue.png
-  - doc/result-RubyPriorityQueue.png
-  - ext/priority_queue
-  - ext/priority_queue/extconf.rb
-  - ext/priority_queue/priority_queue.c
-  - lib/priority_queue.rb
-  - lib/priority_queue
-  - lib/priority_queue/poor_priority_queue.rb
-  - lib/priority_queue/ruby_priority_queue.rb
-  - test/priority_queue_test.rb
-  - benchmark/result-PriorityQueue.gp
-  - benchmark/result-RubyPriorityQueue.gp
-  - benchmark/dijkstra.rb
-  - benchmark/result-PoorPriorityQueue.gp
-  - benchmark/result-CPriorityQueue.png
-  - benchmark/results.csv
-  - benchmark/results.png
-  - benchmark/result-PoorPriorityQueue.png
-  - benchmark/result-RubyPriorityQueue.png
-  - benchmark/results.gp
-  - benchmark/result-CPriorityQueue.gp
+- t.rb
+- Makefile
+- priority_queue.so
+- README
+- priority_queue.o
+- compare_comments.rb
+- CHANGELOG
+- setup.rb
+- ext
+- lib
+- test
+- benchmark
+- ext/priority_queue
+- ext/priority_queue/extconf.rb
+- ext/priority_queue/priority_queue.c
+- lib/priority_queue.rb
+- lib/priority_queue
+- lib/priority_queue/poor_priority_queue.rb
+- lib/priority_queue/ruby_priority_queue.rb
+- test/priority_queue_test.rb
+- benchmark/dijkstra.rb
 test_files: []
+
 rdoc_options: []
+
 extra_rdoc_files: []
+
 executables: []
+
 extensions: 
-  - ext/priority_queue/extconf.rb
+- ext/priority_queue/extconf.rb
 requirements: []
-dependencies: []
+
+dependencies: []
+

data/benchmark/result-CPriorityQueue.gp

@@ -1,8 +0,0 @@
-set term png
-set out 'result-CPriorityQueue.png'
-set xlabel 'Number of nodes'
-set ylabel 'Time in seconds (real)'
-set logscale xy
-set title 'Dijkstras Shortest Path Algorithm on Networks of different degrees'
-plot \
-  'results.csv' using 1:2 with lines title "CPriorityQueue (Graph of Degree: 16)"

data/benchmark/result-PoorPriorityQueue.gp

@@ -1,8 +0,0 @@
-set term png
-set out 'result-PoorPriorityQueue.png'
-set xlabel 'Number of nodes'
-set ylabel 'Time in seconds (real)'
-set logscale xy
-set title 'Dijkstras Shortest Path Algorithm on Networks of different degrees'
-plot \
-  'results.csv' using 1:3 with lines title "PoorPriorityQueue (Graph of Degree: 16)"

data/benchmark/result-PriorityQueue.gp

@@ -1,6 +0,0 @@
-set term png
-set out 'result-PriorityQueue.png'
-set xlabel 'Number of nodes'
-set ylabel 'Time in seconds (real)'
-plot \
-  'results.csv' using 1:2 with lines title "PriorityQueue (Graph of Degree: 16)"

data/benchmark/result-RubyPriorityQueue.gp

@@ -1,8 +0,0 @@
-set term png
-set out 'result-RubyPriorityQueue.png'
-set xlabel 'Number of nodes'
-set ylabel 'Time in seconds (real)'
-set logscale xy
-set title 'Dijkstras Shortest Path Algorithm on Networks of different degrees'
-plot \
-  'results.csv' using 1:4 with lines title "RubyPriorityQueue (Graph of Degree: 16)"

data/benchmark/results.csv

@@ -1,37 +0,0 @@
-size	"CPriorityQueue (Graph of Degree: 16)"	"PoorPriorityQueue (Graph of Degree: 16)"	"RubyPriorityQueue (Graph of Degree: 16)"
-100	0.00583611594306098	0.0372195773654514	0.0697224669986301
-200	0.0115931034088135	0.0454702642228868	0.545423454708523
-300	0.0729258590274387	0.480532619688246	0.325443373786079
-400	0.189983632829454	0.993642012278239	0.342083692550659
-500	0.196244796117147	1.43146456612481	0.533440616395738
-600	0.202457533942329	2.06269836425781	0.600252681308322
-700	0.264183335834079	2.801170402103	0.72682441605462
-800	0.270467466778225	3.94072720739577	0.799134042527941
-900	0.443829695383708	4.89565277099609	0.985143608517117
-1000	0.465132978227403	6.15393000178867	1.00162262386746
-2000	0.740832858615451	27.4882550504473	2.40040622817145
-3000	1.07575758298238	55.2952709992727	3.59957594341702
-4000	1.47195853127374	''	4.79923190010919
-5000	1.86880042817858	''	6.23916390207079
-6000	2.40524856249491	''	7.67889030774434
-7000	2.80519718594021	''	9.1503213511573
-8000	3.32880263858371	''	11.0491805076599
-9000	3.58584565586514	''	11.493485238817
-10000	3.9917475912306	''	13.0166101190779
-20000	8.20343301031325	''	26.9999283419715
-30000	13.1478295061323	''	43.9837118784587
-40000	16.7911659081777	''	''
-50000	22.3882454766168	''	''
-60000	26.7571367687649	''	''
-70000	29.91215411822	''	''
-80000	37.1148204538557	''	''
-90000	''	''	''
-100000	''	''	''
-200000	''	''	''
-300000	''	''	''
-400000	''	''	''
-500000	''	''	''
-600000	''	''	''
-700000	''	''	''
-800000	''	''	''
-900000	''	''	''

data/benchmark/results.gp

@@ -1,10 +0,0 @@
-set term png
-set out 'results.png'
-set xlabel 'Number of nodes'
-set ylabel 'Time in seconds (real)'
-set logscale xy
-set title 'Dijkstras Shortest Path Algorithm using different PQ Implementations'
-plot \
-  'results.csv' using 1:2 with lines title "CPriorityQueue (Graph of Degree: 16)",\
-  'results.csv' using 1:3 with lines title "PoorPriorityQueue (Graph of Degree: 16)",\
-  'results.csv' using 1:4 with lines title "RubyPriorityQueue (Graph of Degree: 16)"

data/test.rb

@@ -1,11 +0,0 @@
-class A
-  def initialize a
-    @a = a
-  end
-
-  def other_a(a)
-    a.instance_eval { @a }
-  end
-end
-
-p A.new(2).other_a(A.new(1))