PriorityQueue 0.1.0

data/CHANGELOG

@@ -0,0 +1,19 @@
+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/README

@@ -0,0 +1,85 @@
+# Ruby extension implementing a priority queue
+
+## 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.
+
+## 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
+
+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".
+
+## 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.
+
+# Todo
+  * Only write documentation once

data/benchmark/dijkstra.rb

@@ -0,0 +1,169 @@
+require 'PriorityQueue/RubyPriorityQueue'
+require 'PriorityQueue/PoorPriorityQueue'
+require 'PriorityQueue/CPriorityQueue'
+require 'pqueue'
+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 ]
+
+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 }
+    degrees.each do | degree |
+      p ignore
+      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/benchmark/result-CPriorityQueue.gp

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,10 @@
+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/ext/priority_queue/extconf.rb

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

data/ext/priority_queue/priority_queue.c

@@ -0,0 +1,874 @@
+/*
+ * :main:CPriorityQueue
+ *
+ * Ruby extension implementing a priority queue
+ * 
+ * This is a fibonacy heap priority queue implementation.
+ *
+ * (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.
+ *
+ * Except for using a value except of a void* the priority queue c-code is ruby
+ * agnostic.
+ *
+ */
+#include <stdlib.h>
+#include <stdio.h>
+#include "ruby.h"
+#include <math.h>
+
+typedef _Bool bool;
+
+#define false 0;
+#define true 1;
+
+// Node Structure
+typedef struct struct_priority_node {
+  unsigned int degree;
+  VALUE priority;
+  VALUE object;
+  struct struct_priority_node* parent;
+  struct struct_priority_node* child;
+  struct struct_priority_node* left;
+  struct struct_priority_node* right;
+  bool mark;
+} priority_node;
+
+// The Priority Queue
+typedef struct {
+  priority_node* rootlist;
+  priority_node* min;
+  unsigned int length;
+  int (*compare_function)(VALUE p1, VALUE p2); // Should return < 0 for a < b, 0 for a == b, > 0 for a > b
+} priority_queue;
+
+////////////////////////////////////////////////////////////////////////////////
+// Node Manipulation Functions
+////////////////////////////////////////////////////////////////////////////////
+
+// Create a priority node structure
+priority_node* create_priority_node(VALUE object, VALUE priority) {
+  priority_node* result = ALLOC(priority_node);
+  result->degree   = 0;
+  result->priority = priority;
+  result->object = object;
+  result->parent = NULL;
+  result->child = NULL;
+  result->left = result;
+  result->right = result;
+  result->mark = false;  
+  return result;
+}
+
+// Use this to free a node struct
+void priority_node_free(priority_node* n) {
+  free(n);
+}
+
+static
+void priority_node_free_recursively(priority_node* n) {
+  if (!n)
+    return;
+
+  priority_node* n1 = n;
+  do {
+    priority_node *n2 = n1->right;
+    priority_node_free_recursively(n1->child);
+    priority_node_free(n1);
+    n1 = n2;
+  } while(n1 != n);
+}
+
+// link two binomial heaps
+static 
+priority_node* link_nodes(priority_queue* q, priority_node* b1, priority_node* b2) {
+  if (q->compare_function(b2->priority, b1->priority) < 0)
+    return link_nodes(q, b2, b1);
+  b2->parent = b1;
+  priority_node* child = b1->child;
+  b1->child = b2;
+  if (child) {
+    b2->left  = child->left;
+    b2->left->right = b2;
+    b2->right = child;
+    b2->right->left = b2;
+  } else {
+    b2->left = b2;
+    b2->right = b2;
+  }
+  b1->degree++;
+  b2->mark = false; // TODO: Check if it is not rather b1 that should be marked as false
+  return b1;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Queue Manipulation Functions
+////////////////////////////////////////////////////////////////////////////////
+
+// Create an empty priority queue
+priority_queue* create_priority_queue(int (*compare_function)(VALUE, VALUE)) {
+  priority_queue *result = ALLOC(priority_queue);
+  result->min = NULL;
+  result->rootlist = NULL;
+  result->length = 0;
+  result->compare_function = compare_function;
+  return result;
+}
+
+// Free a priority queue and all the nodes it contains
+void priority_queue_free(priority_queue* q) {
+  priority_node_free_recursively(q->rootlist);
+  free(q);
+}
+
+// Insert a node into the rootlist
+// Does not change length value
+static
+priority_queue* insert_tree(priority_queue* const q, priority_node* const tree) {
+    if (q->rootlist) {
+      priority_node* l = q->rootlist->left;
+      l->right = tree;
+      q->rootlist->left = tree;
+      tree->left = l;
+      tree->right = q->rootlist;
+      if (q->compare_function(tree->priority, q->min->priority) < 0)
+	q->min = tree;
+    } else {
+      q->rootlist = tree;
+      q->min = tree;
+    }
+    return q;
+}
+
+// Meld two queues into one new queue. We take the first queue and the rootnode of the second queue. // TODO: Expose in API
+static
+priority_queue* meld_queue(priority_queue* q1, priority_node* q2, unsigned int length_q2) {
+  if (!q1->rootlist) {
+    q1->rootlist = q2;
+    q1->min = q2;
+    q1->length = length_q2;
+  } else {
+    priority_node* r1 = q1->rootlist->left;
+    priority_node* r2 = q2->left;  
+
+    q1->rootlist->left = r2;
+    r2->right = q1->rootlist;
+
+    q2->left = r1;
+    r1->right = q2;
+
+    q1->length = q1->length + length_q2;
+
+    if (q1->compare_function(q2->priority, q1->min->priority) < 0)
+      q1->min = q2;
+  }
+
+  return q1;
+}
+
+// Add an object and a priority to a priority queue. Returns a pointer to a
+// priority_node structure, which can be used in delete_node and priority_queue_change_priority
+// operations.
+priority_node* priority_queue_add_node(priority_queue* q, VALUE object, VALUE priority) {
+  priority_node* result = create_priority_node(object, priority);
+  insert_tree(q, result);
+  q->length++;
+  return result;
+}
+
+// Does not change length
+static 
+priority_node* delete_first(priority_queue* const q) {  
+  if (q->rootlist) {
+    priority_node* result = q->rootlist;
+    if (result == result->right)
+      q->rootlist = NULL;
+    else {
+      q->rootlist = result->right;
+      result->left->right = result->right;
+      result->right->left = result->left;
+      result->right = result;
+      result->left = result;
+    }
+    return result;
+  } else {
+    return NULL;
+  }
+}
+
+static
+void assert_pointers_correct(priority_node* n) {
+  if (!n) return;
+
+  priority_node *n1 = n->right;
+  while(n != n1) {
+    if (n1->child && (n1 != n1->child->parent)) 
+      printf("Eltern-Kind Zeiger inkorrekt: %p\n", n);
+
+    if (n1 != n1->right->left)
+      printf("Rechts-links inkorrekt: %p\n", n);
+
+    if (n1 != n1->left->right)
+      printf("links-Rechts inkorrekt: %p\n", n);
+
+    assert_pointers_correct(n1->child);
+    n1 = n1->right;
+  }
+}
+
+// Consolidate a queue in amortized O(log n)
+static 
+void consolidate_queue(priority_queue* const q) {
+  unsigned int array_size = 2 * log(q->length) / log(2) + 1;
+  priority_node* tree_by_degree[array_size];
+  unsigned int i;
+  for (i=0; i<array_size; i++)
+    tree_by_degree[i] = NULL;
+
+  priority_node* n = NULL;
+  while (((n = delete_first(q)))) {
+    priority_node* n1 = NULL;
+    while (((n1 = tree_by_degree[n->degree]))) {
+      tree_by_degree[n->degree] = NULL;
+      n = link_nodes(q, n, n1);
+    }
+    tree_by_degree[n->degree] = n;
+  }
+
+  // Find minimum value in O(log n) 
+  q->rootlist = NULL;
+  q->min = NULL;
+  for (i=0; i<array_size; i++) {    
+    if (tree_by_degree[i] != NULL) {
+      insert_tree(q, tree_by_degree[i]);
+    }
+  }
+}
+
+// Delete and extract priority_node with minimal priority O(log n)
+priority_node* priority_queue_delete_min(priority_queue* q) {
+  if (!q->rootlist) return NULL;
+  priority_node* min = q->min;
+
+  if (q->length == 1){ // length == 1
+    q->rootlist = NULL;
+    q->min = NULL;
+    q->length = 0;
+  } else {
+    unsigned int length = q->length;
+    // Abtrennen.
+    if (q->min == q->rootlist) {
+      if (q->min == q->min->right) {
+	q->rootlist = NULL;
+	q->min = NULL;
+      } else {
+	q->rootlist = q->min->right;
+      }
+    }
+    min->left->right = min->right;
+    min->right->left = min->left;
+    min->left = min;
+    min->right = min;
+    if (min->child) {
+      // Kinder und Eltern trennen, Markierung aufheben, und kleinstes Kind bestimmen.
+      priority_node* n = min->child;
+      do {
+	n->parent = NULL;
+	n->mark = false;
+	n = n->right;
+      } while (n!=min->child);
+
+      // Kinder einf�gen
+      if (q->rootlist) {
+	priority_node* const l1 = q->rootlist->left;
+	priority_node* const l2 = n->left;
+
+	l1->right = n;
+	n->left = l1;
+	l2->right = q->rootlist;
+	q->rootlist->left = l2;
+      } else {
+	q->rootlist = n;
+      }
+    }
+
+    // Gr��e anpassen
+    q->length = length-1;
+
+    // Wieder aufh�bschen
+    consolidate_queue(q);
+  }
+
+  return min;
+}
+
+static
+  priority_queue* cut_node(priority_queue* q, priority_node* n) {
+    if (!n->parent)
+      return q;  
+    n->parent->degree--;
+    if (n->parent->child == n) {
+      if (n->right == n)
+	n->parent->child = NULL;
+      else
+	n->parent->child = n->right;  
+    }
+    n->parent = NULL;
+    n->right->left = n->left;
+    n->left->right = n->right;
+
+    n->right = q->rootlist;
+    n->left  = q->rootlist->left;
+    q->rootlist->left->right = n;
+    q->rootlist->left = n;
+    q->rootlist = n;
+
+    n->mark = false;
+
+    return q;
+  }
+
+// change the priority of a priority_node and restructure the queue
+// Does not free the priority node
+priority_queue* priority_queue_delete(priority_queue* q, priority_node* n) {
+  if (n->child) {
+    priority_node* c = n->child;
+    priority_node* e = n->child;
+    do {
+      priority_node* r = c->right;
+      cut_node(q, c);
+      c = r;
+    } while (c != e);
+  }
+  if (n->parent)
+    cut_node(q, n);
+  if (n == n->right) {
+    q->min = NULL;
+    q->rootlist = NULL;
+  } else {
+    if (q->rootlist == n)
+      q->rootlist = n->right;
+    if (q->min == n) {
+      priority_node* n1 = n->right;
+      q->min = n1;
+      do {
+	if (q->compare_function(n1->priority, q->min->priority) <= 0) 
+	  q->min = n1;
+	n1 = n1->right;
+      } while(n1 != n);
+    }
+    n->right->left = n->left;
+    n->left->right = n->right;
+    n->left = n;
+    n->right = n;
+  }
+  q->length -= 1;
+  return q;
+}
+
+// change the priority of a priority_node and restructure the queue
+priority_queue* priority_queue_change_priority(priority_queue* q, priority_node* n, VALUE priority) {
+  if (q->compare_function(n->priority, priority) <= 0) { // Priority was increased. Remove the node and reinsert.
+    priority_queue_delete(q, n);
+    n->priority = priority;
+    meld_queue(q, n, 1);
+    return q;
+  }    
+  n->priority = priority;
+  if (q->compare_function(n->priority, q->min->priority) < 0)
+    q->min = n;
+  if (!(n->parent) || (q->compare_function(n->parent->priority, n->priority) <= 0)) // Already in rootlist or bigger than parent
+    return q;
+  do { // Cascading Cuts
+    priority_node* p = n->parent;
+    cut_node(q, n);
+    n = p;
+  } while (n->mark && n->parent);
+  if (n->parent)
+    n->mark = true;
+  return q;
+}
+
+// Get the priority_node with the minimum priority from a queue
+priority_node* priority_queue_min(priority_queue *q) {
+  return q->min;
+}
+
+_Bool priority_queue_empty(priority_queue *q) {
+  return q->min == NULL;
+}
+
+// change the priority of a priority_node and restructure the queue
+priority_queue* priority_queue_each_node(priority_queue* q, priority_node* n, 
+    void (*each)(priority_queue* q_, priority_node* n_, void* args), void* arguments) {
+  priority_node* end = n;
+  do {
+    priority_node* next = n->right;
+    (*each)(q, n, arguments);
+    if (n->child)
+      priority_queue_each_node(q, n->child, each, arguments);
+    n = n->right;
+    if (n != next)
+      break;
+  } while (n != end);
+  return q;
+}
+
+priority_queue* priority_queue_each(priority_queue* q,  
+    void (*each)(priority_queue* q, priority_node* n, void* args), void* arguments) {
+  if (q->rootlist)
+    priority_queue_each_node(q, q->rootlist, each, arguments);
+  return q;
+}
+////////////////////////////////////////////////////////////////////////////////
+// Define the ruby classes
+////////////////////////////////////////////////////////////////////////////////
+
+static int id_compare_operator;
+static int id_format;
+static int id_display;
+
+priority_queue* get_pq_from_value(VALUE self) {
+  priority_queue *q; 
+  Data_Get_Struct(self, priority_queue, q);
+  return q;
+}
+
+static
+int priority_compare_function(VALUE a, VALUE b) {
+  return FIX2INT(rb_funcall((VALUE) a, id_compare_operator, 1, (VALUE) b));
+}
+
+static
+void pq_free(void *p) {
+  priority_queue_free(p);
+}
+
+static
+void pq_mark_recursive(priority_node* n) {
+  if (!n) return;
+  rb_gc_mark((VALUE) n->object);
+  rb_gc_mark((VALUE) n->priority);
+  priority_node* n1 = n->child;
+  if (!n1) return;
+  do {
+    pq_mark_recursive(n1);
+    n1 = n1->right;
+  } while (n1 != n->child);
+}
+
+static
+void pq_mark(void *q) {  
+  priority_node* n1 = ((priority_queue*) q)->rootlist;
+  if (!n1)
+    return;
+  priority_node* n2 = n1;
+  do {
+    pq_mark_recursive(n1);
+    n1 = n1->right;
+  } while (n1 != n2);
+}
+
+static 
+VALUE pq_alloc(VALUE klass) {
+  priority_queue *q;
+  VALUE object;
+
+  q = create_priority_queue(&priority_compare_function);
+
+  object = Data_Wrap_Struct(klass, pq_mark, pq_free, q);
+
+  return object;
+}
+
+/*
+ * Create a new, empty PriorityQueue
+ */
+static
+VALUE pq_init(VALUE self) {
+  rb_iv_set(self, "@__node_by_object__", rb_hash_new());
+
+  return self;
+}
+
+/*
+ * Add an object to the queue.
+ */
+static
+VALUE pq_push(VALUE self, VALUE object, VALUE priority) {
+  VALUE hash = rb_iv_get(self, "@__node_by_object__");
+
+  priority_queue* q = get_pq_from_value(self);
+
+  priority_node* n = priority_queue_add_node(q, object, priority);
+
+  rb_hash_aset(hash, object, ULONG2NUM((unsigned long) n)); // TODO: This is hackish, maybe its better to also wrap the nodes.
+
+  return self;
+}
+
+/*
+ * Return the pair [object, priority] with minimal priority
+ */
+static
+VALUE pq_min(VALUE self) {
+  priority_queue* q = get_pq_from_value(self);
+
+  priority_node* n = priority_queue_min(q);
+  if (n)
+    return rb_ary_new3(2, n->object, n->priority);
+  else
+    return Qnil;
+}
+
+/*
+ * Return the key that has the minimal priority
+ */
+static
+VALUE pq_min_key(VALUE self) {
+  priority_queue* q = get_pq_from_value(self);
+
+  priority_node* n = priority_queue_min(q);
+  if (n)
+    return n->object;
+  else
+    return Qnil;
+}
+
+/*
+ * Return the minimal priority
+ */
+static
+VALUE pq_min_priority(VALUE self) {
+  priority_queue* q = get_pq_from_value(self);
+
+  priority_node* n = priority_queue_min(q);
+  if (n)
+    return n->priority;
+  else
+    return Qnil;
+}
+
+/*
+ * Delete key with minimal priority and return [key, priority]
+ */
+static
+VALUE pq_delete_min(VALUE self) {
+  VALUE hash = rb_iv_get(self, "@__node_by_object__");
+  priority_queue* q = get_pq_from_value(self);
+
+  priority_node* n = priority_queue_delete_min(q);
+
+  if (n) {
+    rb_hash_delete(hash, n->object); // TODO: Maybe we have a problem here with garbage collection of n->object?
+    return rb_ary_new3(2, n->object, n->priority);  
+  } else {
+    return Qnil;
+  }
+}
+
+/*
+ * Delete key with minimal priority and return the key
+ */
+static
+VALUE pq_delete_min_return_key(VALUE self) {
+  VALUE hash = rb_iv_get(self, "@__node_by_object__");
+  priority_queue* q = get_pq_from_value(self);
+
+  priority_node* n = priority_queue_delete_min(q);
+
+  if (n) {
+    rb_hash_delete(hash, n->object); // TODO: Maybe we have a problem here with garbage collection of n->object?
+    return n->object;  
+  } else {
+    return Qnil;
+  }
+}
+
+/*
+ * Delete key with minimal priority and return the priority value
+ */
+static
+VALUE pq_delete_min_return_priority(VALUE self) {
+  VALUE hash = rb_iv_get(self, "@__node_by_object__");
+  priority_queue* q = get_pq_from_value(self);
+
+  priority_node* n = priority_queue_delete_min(q);
+
+  if (n) {
+    rb_hash_delete(hash, n->object); // TODO: Maybe we have a problem here with garbage collection of n->object?
+    return n->priority;  
+  } else {
+    return Qnil;
+  }
+}
+
+/*
+ * call-seq:
+ *     queue[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]
+ */
+static
+VALUE pq_change_priority(VALUE self, VALUE object, VALUE priority) {
+  VALUE hash = rb_iv_get(self, "@__node_by_object__");
+  priority_queue* q = get_pq_from_value(self);
+
+  VALUE node = rb_hash_aref(hash, object);
+  if (NIL_P(node)) {
+    pq_push(self, object, priority);
+  } else {
+    priority_queue_change_priority(q, (priority_node*) NUM2ULONG(node), priority);
+  }
+
+  return self;
+}
+
+/*
+ * call-seq:
+ *     queue[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
+ */
+static
+VALUE pq_get_priority(VALUE self, VALUE object) {
+  VALUE hash = rb_iv_get(self, "@__node_by_object__");
+
+  VALUE node_pointer = rb_hash_aref(hash, object);
+  
+  if (NIL_P(node_pointer))
+    return Qnil;
+  else
+    return (VALUE) (((priority_node*) NUM2ULONG(node_pointer))->priority);
+}
+
+/*
+ * 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
+ */
+static
+VALUE pq_has_key(VALUE self, VALUE object) {
+  VALUE hash = rb_iv_get(self, "@__node_by_object__");
+
+  VALUE node_pointer = rb_hash_aref(hash, object);
+  
+  return NIL_P(node_pointer) ? Qfalse : Qtrue;
+}
+/*
+ * Returns the number of elements of the queue.
+ * 
+ *     q = PriorityQueue.new
+ *     q.length #=> 0
+ *     q[0] = 1
+ *     q.length #=> 1
+ */
+static
+VALUE pq_length(VALUE self) {
+  priority_queue* q = get_pq_from_value(self);
+
+  return INT2NUM(q->length);
+}
+
+/*
+ * 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
+ */
+static
+VALUE pq_delete(VALUE self, VALUE object) {
+  priority_queue* q = get_pq_from_value(self);
+
+  VALUE hash = rb_iv_get(self, "@__node_by_object__");
+
+  VALUE node_pointer = rb_hash_aref(hash, object);  
+  
+  if (NIL_P(node_pointer))
+    return Qnil;
+  else {
+    priority_node* n = (priority_node*) NUM2ULONG(node_pointer);
+    VALUE object = n->object;
+    VALUE priority = n->priority;
+    priority_queue_delete(q, n);
+    rb_hash_delete(hash, object);
+    priority_node_free(n);
+    return rb_ary_new3(2, object, priority);
+  }
+}
+
+
+// Dot a single node of a priority queue. Called by pq_to_dot to do the inner work.
+// (I'm not proud of this function ;-( )
+static
+void pq_node2dot(VALUE result_string, priority_node* n, unsigned int level) {
+  if (n == NULL) return;  
+  unsigned int i;
+  for (i=0; i<level; i++) rb_str_cat2(result_string, "  ");  
+  if (n->mark)
+    rb_str_concat(result_string,
+	rb_funcall(Qnil, id_format, 4, rb_str_new2("NODE%i [label=\"%s (%s)\"];\n"), 
+	  ULONG2NUM((unsigned long) n), n->object, n->priority));
+  else
+    rb_str_concat(result_string,
+	rb_funcall(Qnil, id_format, 4, rb_str_new2("NODE%i [label=\"%s (%s)\",shape=box];\n"), 
+	  ULONG2NUM((unsigned long) n), n->object, n->priority));
+  if (n->child != NULL) {
+    priority_node* n1 = n->child;
+    do {
+      pq_node2dot(result_string, n1, level + 1);
+      for (i=0; i<level; i++) rb_str_cat2(result_string, "  ");  
+      rb_str_concat(result_string,
+	  rb_funcall(Qnil, id_format, 4, rb_str_new2("NODE%i -> NODE%i;\n"), 
+	    ULONG2NUM((unsigned long) n), ULONG2NUM((unsigned long) n1)));
+      n1 = n1->right;
+    } while(n1 != n->child);
+  }
+}
+
+/* 
+ * 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.
+ * 
+ * (I'm not proud of this function ;-( )
+ */
+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");
+  if (q->rootlist) {
+    priority_node* n1 = q->rootlist;
+    do {    
+      pq_node2dot(result_string, n1, 1);
+      n1 = n1->right;
+    } while(n1 != q->rootlist);
+  }
+  rb_str_cat2(result_string, "}\n");
+  return result_string;
+}
+
+/*
+ * Returns true if the array is empty, false otherwise.
+ */
+static
+VALUE pq_empty(VALUE self) {
+  priority_queue* q = get_pq_from_value(self);
+  return priority_queue_empty(q) ? Qtrue : Qfalse;
+}
+
+static
+void pq_each_helper(priority_queue *q, priority_node *n, void *args) {
+  rb_yield(rb_ary_new3(2, n->object, n->priority));
+};
+
+/*
+ * 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.
+ */
+static
+VALUE pq_each(VALUE self) {
+  priority_queue* q = get_pq_from_value(self);
+  priority_queue_each(q, &pq_each_helper, NULL);
+  return self;
+}
+
+static
+VALUE pq_insert_node(VALUE node, VALUE queue) {
+  return pq_push(queue, rb_ary_entry(node, 0), rb_ary_entry(node, 1));
+}
+
+static
+VALUE pq_init_copy(VALUE copy, VALUE orig) {
+  if (copy == orig)
+    return copy;
+
+  rb_iterate(rb_each, orig, pq_insert_node, copy);
+  
+  return copy;
+}
+
+/*
+ * Returns a string representation of the priority queue.
+ */
+static
+VALUE pq_inspect(VALUE self) {  
+  VALUE result = rb_str_new2("<PriorityQueue: ");
+  rb_str_concat(result,
+      rb_funcall(rb_funcall(self, rb_intern("to_a"), 0),
+	rb_intern("inspect"), 0));
+  rb_str_concat(result, rb_str_new2(">"));
+  return result;
+}
+
+VALUE cPriorityQueue;
+
+/* 
+ * A Priority Queue implementation
+ *
+ * A priority queue is a queue, where each element (the key) has an assigned
+ * priority.  It is possible to efficently decrease priorities and to
+ * efficently look up and remove the key with the smallest priority.
+ *
+ * This datastructure is used in different algorithms. The standard algorithm
+ * used to introduce priority queues is dijkstra's shortest path algorithm.
+ *
+ * The priority queue includes the Enumerable module.
+ */
+void Init_CPriorityQueue() {
+  id_compare_operator = rb_intern("<=>");
+  id_format = rb_intern("format");
+  id_display = rb_intern("display");
+
+  cPriorityQueue = rb_define_class("CPriorityQueue", rb_cObject);
+
+  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, "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, "change_priority", pq_change_priority, 2);
+  rb_define_method(cPriorityQueue, "[]=", pq_change_priority, 2);
+  rb_define_method(cPriorityQueue, "priority", pq_get_priority, 1);
+  rb_define_method(cPriorityQueue, "[]", pq_get_priority, 1);
+  rb_define_method(cPriorityQueue, "has_key?", pq_has_key, 1);
+  rb_define_method(cPriorityQueue, "length", pq_length, 0);
+  rb_define_method(cPriorityQueue, "to_dot", pq_to_dot, 0);
+  rb_define_method(cPriorityQueue, "empty?", pq_empty, 0);
+  rb_define_method(cPriorityQueue, "delete", pq_delete, 1);
+  rb_define_method(cPriorityQueue, "inspect", pq_inspect, 0);
+  rb_define_method(cPriorityQueue, "each", pq_each, 0);
+  rb_include_module(cPriorityQueue, rb_eval_string("Enumerable"));
+}