bribera-rubyvor 0.0.4 → 0.0.5

data/Manifest.txt

@@ -10,12 +10,12 @@ ext/heap.c
 ext/memory.c
 ext/output.c
 ext/rb_cComputation.c
+ext/rb_cPoint.c
 ext/rb_cPriorityQueue.c
 ext/ruby_vor.c
 ext/ruby_vor.h
 ext/vdefs.h
 ext/voronoi.c
-ext/voronoi_interface.c
 lib/ruby_vor.rb
 lib/ruby_vor/computation.rb
 lib/ruby_vor/point.rb

data/Rakefile

@@ -7,8 +7,7 @@ require './lib/ruby_vor/version.rb'
 EXT = "ext/voronoi_interface.#{Hoe::DLEXT}"
 
 Hoe.new('rubyvor', RubyVor::VERSION) do |p|
-  p.developer('Brendan Ribera', 'brendan.ribera+rubyvor@gmail.com')
-  
+  p.developer('Brendan Ribera', 'brendan.ribera+rubyvor@gmail.com')  
   p.url = 'http://github.com/bribera/rubyvor'
 
   # C extension goodness

data/ext/output.c

@@ -1,24 +1,17 @@
 
 /*** OUTPUT.C ***/
 
-
+#include <vdefs.h>
 #include <stdio.h>
-
-#include "vdefs.h"
+#include <unistd.h>
 
 VoronoiState rubyvorState;
 
 static float pxmin, pxmax, pymin, pymax, cradius;
 
 void openpl(void) {}
-
-#pragma argsused
 void line(float ax, float ay, float bx, float by) {}
-
-#pragma argsused
 void circle(float ax, float ay, float radius) {}
-
-#pragma argsused
 void range(float pxmin, float pxmax, float pymin, float pymax) {}
 
 void

data/ext/rb_cComputation.c

@@ -8,18 +8,16 @@ static Site * nextone(void);
 static int scomp(const void *, const void *);
 
 //
-// Class methods for RubyVor::VDDT::Computation
+// See ruby_vor.c for RDOC
 //
 
 
-/*
- * Compute the voronoi diagram and delaunay triangulation from a set of points.
- *
- * This implementation uses Steven Fortune's sweepline algorithm, which runs in O(n log n) time and O(n) space.
- * It is limited to 2-dimensional space, therefore it expects to receive an array of objects that respond to 'x' and 'y' methods.
- */
+//
+// Class methods for RubyVor::VDDT::Computation
+//
+
 VALUE
-from_points(VALUE self, VALUE pointsArray)
+RubyVor_from_points(VALUE self, VALUE pointsArray)
 {
     //VALUE returnValue;
     VALUE * inPtr, newComp;
@@ -121,16 +119,17 @@ from_points(VALUE self, VALUE pointsArray)
 
 
 //
-// Instance methods (none)
+// Instance methods
 //
 
+/*
 VALUE
-minimum_spanning_tree(int argc, VALUE *argv, VALUE self)
+RubyVor_minimum_spanning_tree(int argc, VALUE *argv, VALUE self)
 {
     VALUE dist_proc, nodes, nnGraph, points, queue, tmpHash, tmpArray, adjList, latestAddition;
     long i, j;
 
-    /* 0 mandatory, 1 optional */
+    // 0 mandatory, 1 optional
     rb_scan_args(argc, argv, "01", &dist_proc);
 
     if (NIL_P(dist_proc)) {
@@ -144,7 +143,7 @@ minimum_spanning_tree(int argc, VALUE *argv, VALUE self)
     points  = rb_iv_get(self, "@points");
     nodes   = rb_ary_new2(RARRAY(points)->len);
     queue   = rb_eval_string("RubyVor::PriorityQueue.new(lambda{|a,b| a[:min_distance] < b[:min_distance]})");
-    nnGraph = nn_graph(self);
+    nnGraph = RubyVor_nn_graph(self);
 
     for (i=0; i < RARRAY(points)->len; i++) {
         tmpHash = rb_hash_new();
@@ -155,7 +154,7 @@ minimum_spanning_tree(int argc, VALUE *argv, VALUE self)
         rb_hash_aset(tmpHash, ID2SYM(rb_intern("min_distance")), (i == 0) ? INT2FIX(0) : rb_const_get(rb_cFloat, rb_intern("MAX")));
         // :parent => nil,
         rb_hash_aset(tmpHash, ID2SYM(rb_intern("parent")), Qnil);
-        // :adjacency_list => nn_graph[n].clone,
+        // :adjacency_list => RubyVor_nn_graph[n].clone,
         rb_hash_aset(tmpHash, ID2SYM(rb_intern("adjacency_list")), rb_funcall(RARRAY(nnGraph)->ptr[i], rb_intern("clone"), 0));
         // :min_adjacency_list => [],
         rb_hash_aset(tmpHash, ID2SYM(rb_intern("min_adjacency_list")), rb_ary_new());
@@ -185,13 +184,14 @@ minimum_spanning_tree(int argc, VALUE *argv, VALUE self)
     
     return tmpArray;
 }
+*/
 
 VALUE
-nn_graph(VALUE self)
+RubyVor_nn_graph(VALUE self)
 {
     long i;
     VALUE dtRaw, graph, points, * dtPtr, * tripletPtr, * graphPtr;
-    ID has_key;
+
     graph = rb_iv_get(self, "@nn_graph");
     
     if (RTEST(graph))

data/ext/rb_cPoint.c

@@ -0,0 +1,14 @@
+#include <ruby.h>
+#include <vdefs.h>
+#include <ruby_vor.h>
+#include <math.h>
+
+/*
+ * Euclidean distance between two Points
+ */
+VALUE
+RubyVor_distance_from(VALUE self, VALUE other)
+{
+    return rb_float_new(sqrt(pow(NUM2DBL(rb_iv_get(self, "@x")) - NUM2DBL(rb_iv_get(other, "@x")), 2.0) +
+                             pow(NUM2DBL(rb_iv_get(self, "@y")) - NUM2DBL(rb_iv_get(other, "@y")), 2.0)));
+}

data/ext/rb_cPriorityQueue.c

@@ -2,37 +2,47 @@
 #include <vdefs.h>
 #include <ruby_vor.h>
 
-VALUE
+//
+// Instance methods for RubyVor::VDDT::PriorityQueue
+//
+
+
+static VALUE
 compare(VALUE a, VALUE b)
 {
     double aD, bD;
     ID minDistance;
     minDistance = ID2SYM(rb_intern("min_distance"));
 
-    if (rb_class_of(a) == rb_cQueueItem)
+    if (rb_class_of(a) == RubyVor_rb_cQueueItem)
         aD = NUM2DBL(rb_funcall(a, rb_intern("priority"), 0));
     else
-        aD = NUM2DBL(a);
+        rb_raise(rb_eTypeError, "wrong argument type %s (expected %s)", rb_obj_classname(a), rb_class2name(RubyVor_rb_cQueueItem));
     
-    if (rb_class_of(b) == rb_cQueueItem)
+    if (rb_class_of(b) == RubyVor_rb_cQueueItem)
         bD = NUM2DBL(rb_funcall(b, rb_intern("priority"), 0));
     else
-        bD = NUM2DBL(b);
+        rb_raise(rb_eTypeError, "wrong argument type %s (expected %s)", rb_obj_classname(b), rb_class2name(RubyVor_rb_cQueueItem));
     
     return RTEST(aD < bD);
 }
 
 VALUE
-percolate_up(VALUE self, VALUE index)
+RubyVor_percolate_up(VALUE self, VALUE index)
 {
     VALUE item, data;
-    long i, j;
+    long i, j, size;
+
+    Check_Type(index, T_FIXNUM);
     
     data = rb_iv_get(self, "@data");
     Check_Type(data, T_ARRAY);
     
-    i = FIX2INT(index);
+    size = FIX2INT(rb_iv_get(self, "@size"));
+    i = FIX2INT(index) + 1;
 
+    if (i < 1 || i > size)
+        rb_raise(rb_eIndexError, "index %i out of range", i-1);
     
     j = i / 2;
     
@@ -41,30 +51,34 @@ percolate_up(VALUE self, VALUE index)
     while(j > 0 && compare(item, RARRAY(data)->ptr[j - 1]))
     {
         rb_ary_store(data, i-1, RARRAY(data)->ptr[j - 1]);
-        rb_funcall(RARRAY(data)->ptr[i-1], rb_intern("index="), 1, INT2FIX(i));
+        rb_funcall(RARRAY(data)->ptr[i-1], rb_intern("index="), 1, INT2FIX(i-1));
         i = j;
         j = j / 2;
     }
 
     rb_ary_store(data, i-1, item);
-    rb_funcall(RARRAY(data)->ptr[i-1], rb_intern("index="), 1, INT2FIX(i));
+    rb_funcall(RARRAY(data)->ptr[i-1], rb_intern("index="), 1, INT2FIX(i-1));
     
     return Qnil;
 }
 
 
 VALUE
-percolate_down(VALUE self, VALUE index)
+RubyVor_percolate_down(VALUE self, VALUE index)
 {
     VALUE item, data;
     long i, j, k, size;
 
+    Check_Type(index, T_FIXNUM);
+
     data = rb_iv_get(self, "@data");
     Check_Type(data, T_ARRAY);
     
     size = FIX2INT(rb_iv_get(self, "@size"));
-    i = FIX2INT(index);
+    i = FIX2INT(index) + 1;
     
+    if (i < 1 || i > size)
+        rb_raise(rb_eIndexError, "index %i out of range", i-1);
     
     j = size / 2;
 
@@ -81,26 +95,26 @@ percolate_down(VALUE self, VALUE index)
         else
         {
             rb_ary_store(data, i-1, RARRAY(data)->ptr[k - 1]);
-            rb_funcall(RARRAY(data)->ptr[i-1], rb_intern("index="), 1, INT2FIX(i));
+            rb_funcall(RARRAY(data)->ptr[i-1], rb_intern("index="), 1, INT2FIX(i-1));
             i = k;
         }
     }
 
     rb_ary_store(data, i-1, item);
-    rb_funcall(RARRAY(data)->ptr[i-1], rb_intern("index="), 1, INT2FIX(i));
+    rb_funcall(RARRAY(data)->ptr[i-1], rb_intern("index="), 1, INT2FIX(i-1));
     
     return Qnil;
 }
 
 
 VALUE
-heapify(VALUE self)
+RubyVor_heapify(VALUE self)
 {
     long i, size;
     size = FIX2INT(rb_iv_get(self, "@size"));
 
     for(i = size / 2; i >= 1; i--)
-        percolate_down(self, INT2FIX(i));
+        RubyVor_percolate_down(self, INT2FIX(i-1));
 
     return Qnil;
 }

data/ext/ruby_vor.c

@@ -2,6 +2,9 @@
 #include <vdefs.h>
 #include <ruby_vor.h>
 
+//
+// Extension initialization
+//
 void
 Init_ruby_vor(void)
 {
@@ -12,30 +15,82 @@ Init_ruby_vor(void)
     /*
      * Main RubyVor namespace.
      */
-    rb_mRubyVor       = rb_define_module("RubyVor");
+    RubyVor_rb_mRubyVor       = rb_define_module("RubyVor");
 
     
     /*
      * Voronoi Digram and Delaunay Triangulation namespace.
      */
-    rb_mVDDT          = rb_define_module_under(rb_mRubyVor, "VDDT");
+    RubyVor_rb_mVDDT          = rb_define_module_under(RubyVor_rb_mRubyVor, "VDDT");
 
     
     /*
      * Class representing a VD/DT computation based on a set of 2-dimensional points
      */
-    rb_cComputation   = rb_define_class_under(rb_mVDDT, "Computation", rb_cObject);
-    rb_define_singleton_method(rb_cComputation, "from_points", from_points, 1);
-    rb_define_method(rb_cComputation, "nn_graph", nn_graph, 0);
-    //rb_define_method(rb_cComputation, "minimum_spanning_tree", minimum_spanning_tree, -1);
+    RubyVor_rb_cComputation   = rb_define_class_under(RubyVor_rb_mVDDT, "Computation", rb_cObject);
+    rb_define_singleton_method(RubyVor_rb_cComputation, "from_points", RubyVor_from_points, 1);
+    rb_define_method(RubyVor_rb_cComputation, "nn_graph", RubyVor_nn_graph, 0);
+    // rb_define_method(RubyVor_rb_cComputation, "minimum_spanning_tree", RubyVor_minimum_spanning_tree, -1);
 
     
     /*
      * A priority queue with a customizable heap-order property.
      */
-    rb_cPriorityQueue = rb_define_class_under(rb_mRubyVor, "PriorityQueue", rb_cObject);
-    rb_cQueueItem = rb_define_class_under(rb_cPriorityQueue, "QueueItem", rb_cObject);
-    rb_define_method(rb_cPriorityQueue, "percolate_up", percolate_up, 1);
-    rb_define_method(rb_cPriorityQueue, "percolate_down", percolate_down, 1);
-    rb_define_method(rb_cPriorityQueue, "heapify", heapify, 0);
+    RubyVor_rb_cPriorityQueue = rb_define_class_under(RubyVor_rb_mRubyVor, "PriorityQueue", rb_cObject);
+    RubyVor_rb_cQueueItem = rb_define_class_under(RubyVor_rb_cPriorityQueue, "QueueItem", rb_cObject);
+    rb_define_method(RubyVor_rb_cPriorityQueue, "percolate_up", RubyVor_percolate_up, 1);
+    rb_define_method(RubyVor_rb_cPriorityQueue, "percolate_down", RubyVor_percolate_down, 1);
+    rb_define_method(RubyVor_rb_cPriorityQueue, "heapify", RubyVor_heapify, 0);
+
+
+    /*
+     * A simple Point class
+     */
+    RubyVor_rb_cPoint = rb_define_class_under(RubyVor_rb_mRubyVor, "Point", rb_cObject);
+    rb_define_method(RubyVor_rb_cPoint, "distance_from", RubyVor_distance_from, 1);
 }
+
+
+
+
+//
+// Method declarations duplicated here for RDOC
+//
+
+/*
+ * Compute the voronoi diagram and delaunay triangulation from a set of points.
+ *
+ * This implementation uses Steven Fortune's sweepline algorithm, which runs in O(n log n) time and O(n) space.
+ * It is limited to 2-dimensional space, therefore it expects to receive an array of objects that respond to 'x' and 'y' methods.
+ */
+VALUE RubyVor_from_points(VALUE, VALUE);
+
+/*
+ * Compute the nearest-neighbor graph using the existing Delaunay triangulation.
+ */
+VALUE RubyVor_nn_graph(VALUE);
+
+/*
+ * Compute the MST for the nearest-nearest graph using a Priority Queue and Prim's algorithm.
+ */
+// VALUE RubyVor_minimum_spanning_tree(int, VALUE*, VALUE);
+
+/*
+ * Move from the given index up, restoring the heap-order property.
+ */
+VALUE RubyVor_percolate_up(VALUE, VALUE);
+
+/*
+ * Move from the index down, restoring the heap-order property.
+ */
+VALUE RubyVor_percolate_down(VALUE, VALUE);
+
+/*
+ * Restore the heap-order property for a randomly ordered array of entries.
+ */
+VALUE RubyVor_heapify(VALUE);
+
+/*
+ * Compute the Euclidean distance between two points.
+ */
+VALUE RubyVor_distance_from(VALUE, VALUE);

data/ext/ruby_vor.h

@@ -4,20 +4,24 @@
 extern VoronoiState rubyvorState;
 
 /* Base modules */
-VALUE rb_mRubyVor;
-VALUE rb_mVDDT;
+VALUE RubyVor_rb_mRubyVor;
+VALUE RubyVor_rb_mVDDT;
 
 /* Computation */
-VALUE rb_cComputation;
-VALUE from_points(VALUE, VALUE);
-VALUE nn_graph(VALUE);
-VALUE minimum_spanning_tree(int, VALUE*, VALUE);
+VALUE RubyVor_rb_cComputation;
+VALUE RubyVor_from_points(VALUE, VALUE);
+VALUE RubyVor_nn_graph(VALUE);
+// VALUE minimum_spanning_tree(int, VALUE*, VALUE);
 
 /* PriorityQueue */
-VALUE rb_cPriorityQueue;
-VALUE rb_cQueueItem;
-VALUE percolate_up(VALUE, VALUE);
-VALUE percolate_down(VALUE, VALUE);
-VALUE heapify(VALUE);
+VALUE RubyVor_rb_cPriorityQueue;
+VALUE RubyVor_rb_cQueueItem;
+VALUE RubyVor_percolate_up(VALUE, VALUE);
+VALUE RubyVor_percolate_down(VALUE, VALUE);
+VALUE RubyVor_heapify(VALUE);
+
+/* Point */
+VALUE RubyVor_rb_cPoint;
+VALUE RubyVor_distance_from(VALUE, VALUE);
 
 #endif

data/lib/ruby_vor/computation.rb

@@ -20,15 +20,14 @@ module RubyVor
 
         clusters = []
         nodes    = (0..points.length-1).to_a
-        visited  = []
-        
+        visited  = [false] * points.length
+        graph    = []
         v = 0
-        graph = nn_graph.map do |neighbors|
-          neighbors = neighbors.reject do |neighbor|
-            dist_proc[points[v], points[neighbor]] > max_distance            
+        
+        nn_graph.each_with_index do |neighbors,v|
+          graph[v] = neighbors.select do |neighbor|
+            dist_proc[points[v], points[neighbor]] < max_distance
           end
-          v += 1
-          neighbors
         end
         
         until nodes.empty?
@@ -63,37 +62,49 @@ module RubyVor
         nodes = []
         q = RubyVor::PriorityQueue.new
         (0..points.length-1).to_a.map do |n|
-          q.push({
-            :node => n,
-            :parent => nil,
-            :adjacency_list => nn_graph[n].clone,
-            :min_adjacency_list => [],
-            :in_q => true
-          }, (n == 0) ? 0.0 : Float::MAX)
-        end
-        
-        q.data.each do |n|
-          n.data[:adjacency_list].map!{|v| q.data[v]}
-          nodes.push(n)
+          q.push([
+                  n,                 #               :node == 0
+                  nil,               #             :parent == 1
+                  nn_graph[n].clone, #     :adjacency_list == 2
+                  [],                # :min_adjacency_list == 3
+                  true               #               :in_q == 4
+                 ],
+                 # Set min_distance of first node to 0, all others (effectively) to Infinity.
+                 (n == 0) ? 0.0 : Float::MAX)
         end
 
-        while latest_addition = q.pop          
-          latest_addition.data[:in_q] = false
+        # Adjacency list accces
+        nodes = q.data.clone
+
+        # We have now prepped to run through Prim's algorithm.
+        while latest_addition = q.pop
+          # check :in_q
+          latest_addition.data[4] = false
 
-          if latest_addition.data[:parent]
-            latest_addition.data[:parent].data[:min_adjacency_list].push(latest_addition)
-            latest_addition.data[:min_adjacency_list].push(latest_addition.data[:parent])
+          # check :parent
+          if latest_addition.data[1]
+            # push this node into :adjacency_list of :parent
+            latest_addition.data[1].data[3].push(latest_addition)
+            # push :parent into :adjacency_list of this node
+            latest_addition.data[3].push(latest_addition.data[1])
           end
 
-          latest_addition.data[:adjacency_list].each do |adjacent|
-            
-            if adjacent.data[:in_q]
+          latest_addition.data[2].each do |adjacent|
+            # grab indexed node
+            adjacent = nodes[adjacent]
 
-              adjacent_distance = dist_proc[ points[latest_addition.data[:node]], points[adjacent.data[:node]] ]
-              
+            # check :in_q -- only look at new nodes
+            if adjacent.data[4]
+              # compare points by :node -- adjacent against current
+              adjacent_distance = dist_proc[ points[latest_addition.data[0]], points[adjacent.data[0]] ]
+
+              # if the new distance is better than our current priorty, exchange them
               if adjacent_distance < adjacent.priority
-                adjacent.data[:parent] = latest_addition
+                # set new :parent
+                adjacent.data[1] = latest_addition
+                # update priority
                 adjacent.priority = adjacent_distance
+                # percolate up into correct position
                 q.percolate_up(adjacent.index)
               end
             end
@@ -103,15 +114,19 @@ module RubyVor
 
 
         nodes.map! do |n|
-          n.data[:min_adjacency_list].map!{|v| v.data[:node]}
+          n.data[3].inject({}) do |h,v|
+            h[v.data[0]] = v.priority
+            h
+          end
         end
       end
 
       def cluster_by_size(sizes=[])
         # TODO
-        # * Create a minimum_spanning_tree routine to:
-        #   1. compute weights (should be done for us in C?)
-        #   2. Use Prim's algorithm for computation
+        # *    (DONE) Create a minimum_spanning_tree routine to:
+        #   1. (DONE) compute weights (should be done for us in C?)
+        #   2. (DONE) Use Prim's algorithm for computation
+        #
         # * Take MST, and
         #   1. For n in sizes (taken in descending order), delete the n most expensive edges from MST
         #     * use a MaxHeap?

data/lib/ruby_vor/point.rb

@@ -1,13 +1,8 @@
 module RubyVor
-  # Basic 2-d point
   class Point
     attr_accessor :x, :y
     def initialize(x=0.0,y=0.0)
       @x = x; @y = y
     end
-
-    def distance_from(p)
-      ((self.x - p.x) ** 2 + (self.y - p.y) ** 2) ** 0.5
-    end
   end
 end

data/lib/ruby_vor/priority_queue.rb

@@ -3,10 +3,9 @@ module RubyVor
 
     attr_reader :data, :size
     
-    def initialize(d=[])
-      @data = d || []
-      @size = d.length
-
+    def initialize()
+      @data = []
+      @size = 0
       heapify()
     end
 
@@ -20,20 +19,20 @@ module RubyVor
       r = @data[0]
 
       @data[0] = @data[@size-1]
-      @data[0].index = 1
+      @data[0].index = 0
       @data.delete_at(@size-1)
 
       @size -= 1
       
-      percolate_down(1) if @size > 0
+      percolate_down(0) if @size > 0
 
       return r
     end
 
-    def push(data, priority=Float::MAX)
+    def push(data, priority=data)
       @size += 1
       @data[@size - 1] = QueueItem.new(priority, @size - 1, data)
-      percolate_up(@size)
+      percolate_up(@size - 1)
     end
 
     # Implemented in C

data/lib/ruby_vor/version.rb

@@ -1,3 +1,3 @@
 module RubyVor
-  VERSION = '0.0.4'
+  VERSION = '0.0.5'
 end

data/rubyvor.gemspec

@@ -2,16 +2,16 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rubyvor}
-  s.version = "0.0.4"
+  s.version = "0.0.5"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Brendan Ribera"]
-  s.date = %q{2008-12-10}
+  s.date = %q{2008-12-11}
   s.description = %q{RubyVor provides efficient computation of Voronoi diagrams and Delaunay triangulation for a set of Ruby points. It is intended to function as a complemenet to GeoRuby. These structures can be used to compute a nearest-neighbor graph for a set of points. This graph can in turn be used for proximity-based clustering of the input points.}
   s.email = ["brendan.ribera+rubyvor@gmail.com"]
   s.extensions = ["ext/extconf.rb"]
   s.extra_rdoc_files = ["History.txt", "Manifest.txt", "README.txt"]
-  s.files = ["History.txt", "Manifest.txt", "README.txt", "Rakefile", "ext/Doc", "ext/edgelist.c", "ext/extconf.rb", "ext/geometry.c", "ext/heap.c", "ext/memory.c", "ext/output.c", "ext/rb_cComputation.c", "ext/rb_cPriorityQueue.c", "ext/ruby_vor.c", "ext/ruby_vor.h", "ext/vdefs.h", "ext/voronoi.c", "ext/voronoi_interface.c", "lib/ruby_vor.rb", "lib/ruby_vor/computation.rb", "lib/ruby_vor/point.rb", "lib/ruby_vor/priority_queue.rb", "lib/ruby_vor/version.rb", "rubyvor.gemspec", "test/test_computation.rb", "test/test_priority_queue.rb", "test/test_voronoi_interface.rb"]
+  s.files = ["History.txt", "Manifest.txt", "README.txt", "Rakefile", "ext/Doc", "ext/edgelist.c", "ext/extconf.rb", "ext/geometry.c", "ext/heap.c", "ext/memory.c", "ext/output.c", "ext/rb_cComputation.c", "ext/rb_cPoint.c", "ext/rb_cPriorityQueue.c", "ext/ruby_vor.c", "ext/ruby_vor.h", "ext/vdefs.h", "ext/voronoi.c", "lib/ruby_vor.rb", "lib/ruby_vor/computation.rb", "lib/ruby_vor/point.rb", "lib/ruby_vor/priority_queue.rb", "lib/ruby_vor/version.rb", "rubyvor.gemspec", "test/test_computation.rb", "test/test_priority_queue.rb", "test/test_voronoi_interface.rb"]
   s.has_rdoc = true
   s.homepage = %q{http://github.com/bribera/rubyvor}
   s.rdoc_options = ["--main", "README.txt"]

data/test/test_computation.rb

@@ -53,9 +53,11 @@ class TestComputation < MiniTest::Unit::TestCase
                     [0,2],
                     [1]
                    ]
+    computed_mst = comp.minimum_spanning_tree
 
+    # Assert nodes are correct
     assert_equal expected_mst.map{|v| v.sort}.sort, \
-                 comp.minimum_spanning_tree.map{|v| v.sort}.sort
+                 computed_mst.map{|v| v.keys.sort}.sort
   end
   
   def test_advanced_mst
@@ -119,8 +121,10 @@ class TestComputation < MiniTest::Unit::TestCase
                     [22,24],   # 23
                     [23]       # 24
                    ]
+    computed_mst = comp.minimum_spanning_tree
+    
     assert_equal expected_mst.map{|v| v.sort}.sort, \
-                 comp.minimum_spanning_tree.map{|v| v.sort}.sort
+                 computed_mst.map{|v| v.keys.sort}.sort
   end
   
   def test_cluster_by_distance
@@ -146,6 +150,29 @@ class TestComputation < MiniTest::Unit::TestCase
 
   end
 
+  def test_bad_data
+    assert_raises TypeError do
+      comp = RubyVor::VDDT::Computation.from_points([RubyVor::Point.new(1,1), RubyVor::Point.new(21,3), RubyVor::Point.new(2,:s)])
+    end
+    
+    assert_raises TypeError do
+      comp = RubyVor::VDDT::Computation.from_points(RubyVor::Point.new(21,3))
+    end
+    
+    assert_raises RuntimeError do
+      comp = RubyVor::VDDT::Computation.from_points([RubyVor::Point.new(1,1), RubyVor::Point.new(21,3), nil])
+    end
+    
+    assert_raises RuntimeError do
+      comp = RubyVor::VDDT::Computation.from_points([])
+    end
+
+    comp = RubyVor::VDDT::Computation.from_points([RubyVor::Point.new(1,1), RubyVor::Point.new(21,3), RubyVor::Point.new(2,1.5)])
+    assert_raises ArgumentError do
+      cl = comp.cluster_by_distance(nil)
+    end
+  end
+
   #
   # A few helper methods
   #

data/test/test_priority_queue.rb

@@ -9,7 +9,7 @@ class TestPriorityQueue < MiniTest::Unit::TestCase
     q = RubyVor::PriorityQueue.new
 
     items = [1,2,3,4,5,6,99,4,-20,101,5412,2,-1,-1,-1,33.0,0,55,7,12321,123.123,-123.123,0,0,0]
-    items.each{|i| q.push(i,i)}
+    items.each{|i| q.push(i)}
 
     items.sort!
     idx = 0
@@ -31,26 +31,83 @@ class TestPriorityQueue < MiniTest::Unit::TestCase
   def test_heapify
     q = RubyVor::PriorityQueue.new
 
-    ([10] * 10).each{|x| q.push(x,x)}
+    # Create a randomized data set.
+    #
+    # Not ideal for unit tests, since they *should* be done
+    # on static data so that failure/success is deterministic...
+    # but works for me.
 
-    q.data[3] = RubyVor::PriorityQueue::QueueItem.new(-34, 3, -34)
-    q.data[4] = RubyVor::PriorityQueue::QueueItem.new(1, 4, 1)
-    q.data[5] = RubyVor::PriorityQueue::QueueItem.new(100, 5, 100)
-    q.data[7] = RubyVor::PriorityQueue::QueueItem.new(0.9, 7, 0.9)
-    q.data.sort!{|a,b| rand(3)-1}
-    
+    100.times{ q.push(rand * 10000.0 - 5000.0)}
+      
+    # Set things right.
     q.heapify()
 
-    assert_equal(-34, q.pop.data)
-    assert_equal 0.9, q.pop.data
-    assert_equal 1,   q.pop.data
-    assert_equal 10,  q.pop.data
-    assert_equal 10,  q.pop.data
-    assert_equal 10,  q.pop.data
-    assert_equal 10,  q.pop.data
-    assert_equal 10,  q.pop.data
-    assert_equal 10,  q.pop.data
-    assert_equal 100, q.pop.data
+    old_n = -1.0 * Float::MAX
+    while n = q.pop
+      assert n.priority >= old_n
+      old_n = n.priority
+    end
   end
+
+  def test_bad_data
+    q = RubyVor::PriorityQueue.new
+    10.times { q.push(rand * 100.0 - 50.0) }
   
+    #
+    # Heapify
+    #
+    old_data = q.data[1]
+    q.data[1] = 45
+    assert_raises TypeError do
+      q.heapify()
+    end
+    q.data[1] = old_data
+    assert_nothing_raised do
+      q.heapify()
+    end
+    
+
+    #
+    # Percolation
+    #
+    [100, -100].each do |i|
+      assert_raises IndexError do
+        q.percolate_up(i)
+      end
+      assert_raises IndexError do
+        q.percolate_down(i)
+      end
+    end
+    [:x, Class, nil, false].each do |i|
+      assert_raises TypeError do
+        q.percolate_up(i)
+      end
+      assert_raises TypeError do
+        q.percolate_down(i)
+      end
+    end
+    [0,1,2,3].each do |i|
+      assert_nothing_raised do
+        q.percolate_up(i)
+      end
+      assert_nothing_raised do
+        q.percolate_down(i)
+      end
+    end
+  end
+
+  
+  private
+  
+  def assert_nothing_raised(&b)
+    begin
+      yield
+    rescue Exception => e
+      flunk "#{mu_pp(e)} exception encountered, expected no exceptions"
+      return
+    end
+    pass()
+  end
 end
+
+MiniTest::Unit.autorun

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: bribera-rubyvor
 version: !ruby/object:Gem::Version 
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors: 
 - Brendan Ribera
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-12-10 00:00:00 -08:00
+date: 2008-12-11 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -45,12 +45,12 @@ files:
 - ext/memory.c
 - ext/output.c
 - ext/rb_cComputation.c
+- ext/rb_cPoint.c
 - ext/rb_cPriorityQueue.c
 - ext/ruby_vor.c
 - ext/ruby_vor.h
 - ext/vdefs.h
 - ext/voronoi.c
-- ext/voronoi_interface.c
 - lib/ruby_vor.rb
 - lib/ruby_vor/computation.rb
 - lib/ruby_vor/point.rb