bribera-rubyvor 0.0.7 → 0.0.8

data/History.txt

@@ -1,3 +1,9 @@
+=== 0.0.8 / 2008-12-23
+
+* Several C warning fixes (more ISO C compliance unused variables, etc)
+* Moved minimum_spanning_tree computation into C, yielding large speed gain.
+* Basic SVG visualization.
+
 === 0.0.7 / 2008-12-12
 
 * Bugfix: there are cases where performing a Delaunay triangulation on a set of points will not yield a complete nearest neighbor graph. This causes computation of the minimum spanning tree and clustering to fail for these nodes (they always appear as disconnected from the main graph).

data/Manifest.txt

@@ -22,6 +22,7 @@ lib/ruby_vor/geo_ruby_extensions.rb
 lib/ruby_vor/point.rb
 lib/ruby_vor/priority_queue.rb
 lib/ruby_vor/version.rb
+lib/ruby_vor/visualizer.rb
 rubyvor.gemspec
 test/test_computation.rb
 test/test_priority_queue.rb

data/README.txt

@@ -12,7 +12,38 @@ in turn be used for proximity-based clustering of the input points.
 
 == Usage:
 
-TODO
+require 'lib/ruby_vor'
+require 'pp'
+
+points = [
+  RubyVor::Point.new(120, 290),
+  RubyVor::Point.new(110, 120),
+  RubyVor::Point.new(160, 90.2),
+  RubyVor::Point.new(3.14159265, 3.14159265)
+]
+
+# Compute the diagram & triangulation
+comp = RubyVor::VDDT::Computation.from_points(points)
+
+puts "The nearest-neighbor graph:"
+pp comp.nn_graph
+
+puts "\nThe minimum-spanning tree:"
+pp comp.minimum_spanning_tree
+
+#
+# Visualize these things as SVGs
+#
+
+# Just the triangulation
+RubyVor::Visualizer.make_svg(comp, :name => 'tri.svg')
+
+# Just the MST
+RubyVor::Visualizer.make_svg(comp, :name => 'mst.svg', :triangulation => false, :mst => true)
+
+# Voronoi diagram and the triangulation
+RubyVor::Visualizer.make_svg(comp, :name => 'dia.svg', :voronoi_diagram => true)
+
 
 == LICENSE:
 

data/ext/memory.c

@@ -86,9 +86,11 @@ myrealloc(void * oldp, unsigned n, unsigned oldn)
 
     update_memory_map(newp);
 
-    // Mark oldp as freed, since free() was called by realloc.
-    //
-    // TODO: this seems naive; measure if this is a bottleneck & use a hash table or some other scheme if it is.
+    /*
+     * Mark oldp as freed, since free() was called by realloc.
+     *
+     * TODO: this seems naive; measure if this is a bottleneck & use a hash table or some other scheme if it is.
+     */
     for (i=0; i<nallocs; i++)
     {
         if (memory_map[i] != (char*)0 && memory_map[i] == oldp)

data/ext/output.c

@@ -17,11 +17,11 @@ void range(float pxmin, float pxmax, float pymin, float pymax) {}
 void
 out_bisector(Edge * e)
 {
-    // Save line to our ruby object
+    /* Save line to our ruby object */
     (*rubyvorState.storeL)(e->a, e->b, e->c);
 
     
-    // printf("l %f %f %f\n", e->a, e->b, e->c);
+    /* printf("l %f %f %f\n", e->a, e->b, e->c); */
     
     if (rubyvorState.plot)
         line(e->reg[0]->coord.x, e->reg[0]->coord.y, e->reg[1]->coord.x, e->reg[1]->coord.y);
@@ -33,7 +33,7 @@ out_bisector(Edge * e)
 void
 out_ep(Edge * e)
 {
-    // Save endpoint to our ruby object
+    /* Save endpoint to our ruby object */
     (*rubyvorState.storeE)(e->edgenbr,
                            e->ep[le] != (Site *)NULL ? e->ep[le]->sitenbr : -1,
                            e->ep[re] != (Site *)NULL ? e->ep[re]->sitenbr : -1);
@@ -51,10 +51,10 @@ out_ep(Edge * e)
 void
 out_vertex(Site * v)
 {
-    // Save vertex to our ruby object
+    /* Save vertex to our ruby object */
     (*rubyvorState.storeV)(v->coord.x, v->coord.y);
     
-    // printf ("v %f %f\n", v->coord.x, v->coord.y) ;
+    /* printf ("v %f %f\n", v->coord.x, v->coord.y) ; */
     
     if (rubyvorState.debug)
         printf("vertex(%d) at %f %f\n", v->sitenbr, v->coord.x, v->coord.y);
@@ -63,10 +63,10 @@ out_vertex(Site * v)
 void
 out_site(Site * s)
 {
-    // Save site to our ruby object
+    /* Save site to our ruby object */
     (*rubyvorState.storeS)(s->coord.x, s->coord.y);
 
-    //printf("s %f %f\n", s->coord.x, s->coord.y) ;
+    /* printf("s %f %f\n", s->coord.x, s->coord.y) ; */
 
     if (rubyvorState.plot)
         circle (s->coord.x, s->coord.y, cradius);
@@ -78,7 +78,7 @@ out_site(Site * s)
 void
 out_triple(Site * s1, Site * s2, Site * s3)
 {
-    // Save triplet to our ruby object
+    /* Save triplet to our ruby object */
     (*rubyvorState.storeT)(s1->sitenbr, s2->sitenbr, s3->sitenbr);
     
     if (rubyvorState.debug)
@@ -222,14 +222,13 @@ clip_line(Edge * e)
 /* Linux-specific. */
 void
 debug_memory(void)
-{
-    if (!rubyvorState.debug)
-        return;
-    
+{    
     char buf[30];
     FILE* pf;
+    int tmp;
+    float totalSize;
+    unsigned size;/*       total program size */
 
-    unsigned size;//       total program size
     /*
     unsigned resident;//   resident set size
     unsigned share;//      shared pages
@@ -238,18 +237,15 @@ debug_memory(void)
     unsigned data;//       data/stack
     unsigned dt;//         dirty pages (unused in Linux 2.6)
     */
-    
-    int retVal;
 
-    float totalSize;
+    if (!rubyvorState.debug)
+        return;
     
     snprintf(buf, 30, "/proc/%u/statm", (unsigned)getpid());
     pf = fopen(buf, "r");
     if (NULL != pf)
     {
-        retVal = fscanf(pf, "%u", &size);
-        //, %u, %u ... etc &resident, &share, &text, &lib, &data);
-        
+        tmp = fscanf(pf, "%u", &size); /*, %u, %u ... etc &resident, &share, &text, &lib, &data); */
         totalSize = (float)size / 1024.0;
         fprintf(stderr, "%f ", totalSize);
     }

data/ext/rb_cComputation.c

@@ -7,83 +7,86 @@
 static Site * nextone(void);
 static int scomp(const void *, const void *);
 
-//
-// See ruby_vor.c for RDOC
-//
+/*
+ * See ruby_vor.c for RDOC
+ */
 
 
-//
-// Class methods for RubyVor::VDDT::Computation
-//
+/*
+ * Class methods for RubyVor::VDDT::Computation
+ */
 
 VALUE
 RubyVor_from_points(VALUE self, VALUE pointsArray)
 {
-    //VALUE returnValue;
     VALUE * inPtr, newComp;
     ID x, y;
 
     long i, inSize;
 
-    // Require T_ARRAY
+    /* Require T_ARRAY */
     Check_Type(pointsArray, T_ARRAY);
 
-    // Intern our point access methods
+    /* Intern our point access methods */
     x = rb_intern("x");
     y = rb_intern("y");
 
-    // Load up point count & points pointer.
-    inSize = RARRAY(pointsArray)->len;
-    inPtr  = RARRAY(pointsArray)->ptr;
 
-    // Require nonzero size and x & y methods on each array object
-    if (inSize < 1)
+    /* Require nonzero size and x & y methods on each array object */
+    if (RARRAY(pointsArray)->len < 1)
         rb_raise(rb_eRuntimeError, "points array have a nonzero length");
-    for (i = 0; i < inSize; i++) {
-        if(!rb_respond_to(inPtr[i], x) || !rb_respond_to(inPtr[i], y))
+    for (i = 0; i < RARRAY(pointsArray)->len; i++) {
+        if(!rb_respond_to(RARRAY(pointsArray)->ptr[i], x) || !rb_respond_to(RARRAY(pointsArray)->ptr[i], y))
             rb_raise(rb_eRuntimeError, "members of points array must respond to 'x' and 'y'");
     }
 
+    /* Load up point count & points pointer. */
+    pointsArray = rb_funcall(pointsArray, rb_intern("uniq"), 0);
+    inSize = RARRAY(pointsArray)->len;
+    inPtr  = RARRAY(pointsArray)->ptr;
+
     
-    // Initialize rubyvorState
-    initialize_state(/* debug? */ 0);
+    /* Initialize rubyvorState */
+    initialize_state(0 /* debug? */);
     debug_memory();
     
-    // Create our return object.
-    newComp = rb_funcall(self, rb_intern("new"), 1, pointsArray);
-    // Store it in rubyvorState so we can populate its values.
+    /* Create our return object. */
+    newComp = rb_funcall(self, rb_intern("new"), 0);
+    rb_iv_set(newComp, "@points", pointsArray);
+    
+    /* Store it in rubyvorState so we can populate its values. */
     rubyvorState.comp = (void *) &newComp;
-    //
-    // Read in the sites, sort, and compute xmin, xmax, ymin, ymax
-    //
-    // TODO: refactor this block into a separate method for clarity?
-    //
+    
+    /*
+     * Read in the sites, sort, and compute xmin, xmax, ymin, ymax
+     *
+     * TODO: refactor this block into a separate method for clarity?
+     */
     {
-        // Allocate memory for 4000 sites...
-        rubyvorState.sites = (Site *) myalloc(4000 * sizeof(Site));
+        /* Allocate memory for N sites... */
+        rubyvorState.sites = (Site *) myalloc(inSize * sizeof(Site));
     
     
-        // Iterate over the arrays, doubling the incoming values.
+        /* Iterate over the arrays, doubling the incoming values. */
         for (i=0; i<inSize; i++)
         {
             rubyvorState.sites[rubyvorState.nsites].coord.x = NUM2DBL(rb_funcall(inPtr[i], x, 0));
             rubyvorState.sites[rubyvorState.nsites].coord.y = NUM2DBL(rb_funcall(inPtr[i], y, 0));
-            
-            // 
+             
             rubyvorState.sites[rubyvorState.nsites].sitenbr = rubyvorState.nsites;
             rubyvorState.sites[rubyvorState.nsites++].refcnt = 0;
             
-            // Allocate for 4000 more if we just hit a multiple of 4000...
-            if (rubyvorState.nsites % 4000 == 0)
+            /* Allocate for N more if we just hit a multiple of N... */
+            if (rubyvorState.nsites % inSize == 0)
             {
-                rubyvorState.sites = (Site *)myrealloc(rubyvorState.sites,(rubyvorState.nsites+4000)*sizeof(Site),rubyvorState.nsites*sizeof(Site));
+                rubyvorState.sites = (Site *)myrealloc(rubyvorState.sites,(rubyvorState.nsites+inSize)*sizeof(Site),rubyvorState.nsites*sizeof(Site));
             }
         }
         
-        // Sort the Sites
+        /* Sort the Sites */
         qsort((void *)rubyvorState.sites, rubyvorState.nsites, sizeof(Site), scomp) ;
         
-        // Pull the minimum values.
+        /* Pull the minimum values. */
         rubyvorState.xmin = rubyvorState.sites[0].coord.x;
         rubyvorState.xmax = rubyvorState.sites[0].coord.x;
         for (i=1; i < rubyvorState.nsites; ++i)
@@ -103,14 +106,14 @@ RubyVor_from_points(VALUE self, VALUE pointsArray)
     }
 
     
-    // Perform the computation
+    /* Perform the computation */
     voronoi(nextone);
     debug_memory();
     
-    // Get rid of our comp reference
+    /* Get rid of our comp reference */
     rubyvorState.comp = (void *)NULL;
     
-    // Free our allocated objects
+    /* Free our allocated objects */
     free_all();    
     debug_memory();
 
@@ -118,78 +121,127 @@ RubyVor_from_points(VALUE self, VALUE pointsArray)
 }
 
 
-//
-// Instance methods
-//
-
 /*
+ * Instance methods
+ */
+
 VALUE
 RubyVor_minimum_spanning_tree(int argc, VALUE *argv, VALUE self)
 {
-    VALUE dist_proc, nodes, nnGraph, points, queue, tmpHash, tmpArray, adjList, latestAddition;
-    long i, j;
+    VALUE mst, dist_proc, nodes, nnGraph, points, queue, tmp, adjacent, adjacentData, adjacentDistance, latestAddition, latestAdditionData, floatMax;
+    long i;
 
-    // 0 mandatory, 1 optional
+    /* 0 mandatory, 1 optional */
     rb_scan_args(argc, argv, "01", &dist_proc);
 
+    mst = rb_iv_get(self, "@mst");
+    
+    if (RTEST(mst))
+        return mst;
+
+
     if (NIL_P(dist_proc)) {
-        // Use our default Proc
+        /* Use our default Proc */
         dist_proc = rb_eval_string("lambda{|a,b| a.distance_from(b)}");
     } else if (rb_class_of(dist_proc) != rb_cProc) {
-        // Blow up if we have a non-nil, non-Proc
+        /* Blow up if we have a non-nil, non-Proc */
         rb_raise(rb_eTypeError, "wrong argument type %s (expected %s)", rb_obj_classname(dist_proc), rb_class2name(rb_cProc));
     }
 
     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]})");
+    queue   = rb_eval_string("RubyVor::PriorityQueue.new");
     nnGraph = RubyVor_nn_graph(self);
-
-    for (i=0; i < RARRAY(points)->len; i++) {
-        tmpHash = rb_hash_new();
-
-        // :node => n,
-        rb_hash_aset(tmpHash, ID2SYM(rb_intern("node")), INT2FIX(i));
-        // :min_distance => (n == 0) ? 0.0 : Float::MAX,
-        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 => 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());
-        // :in_q => true
-        rb_hash_aset(tmpHash, ID2SYM(rb_intern("in_q")), Qtrue);
-        
-        rb_funcall(queue, rb_intern("push"), 1, tmpHash);
+    floatMax= rb_iv_get(rb_cFloat, "MAX");
+
+    for (i = 0; i < RARRAY(points)->len; i++) {
+        tmp = rb_ary_new2(5);
+        /* 0: node index */
+        rb_ary_push(tmp, LONG2FIX(i));
+        /* 1: parent */
+        rb_ary_push(tmp, Qnil);
+        /* 2: adjacency_list */
+        rb_ary_push(tmp, rb_obj_clone(RARRAY(nnGraph)->ptr[i]));
+        /* 3: min_adjacency_list */
+        rb_ary_push(tmp, rb_ary_new());
+        /* 4: in_q */
+        rb_ary_push(tmp, Qtrue);
+
+        rb_funcall(queue, rb_intern("push"), 2, tmp, (i == 0) ? rb_float_new(0.0) : floatMax);
     }
+    nodes = rb_obj_clone(rb_funcall(queue, rb_intern("data"), 0));
+    
+    while(RTEST(latestAddition = rb_funcall(queue, rb_intern("pop"), 0))) {
+        latestAdditionData = rb_funcall(latestAddition, rb_intern("data"), 0);
+        
+        /* mark in_q */
+        rb_ary_store(latestAdditionData, 4, Qfalse);
+
+        /* check for presence of parent */
+        if (RTEST(RARRAY(latestAdditionData)->ptr[1])) {
+            /* push this node into adjacency_list of parent */
+            rb_ary_push(RARRAY(rb_funcall(RARRAY(latestAdditionData)->ptr[1], rb_intern("data"), 0))->ptr[3], latestAddition);
+            /* push parent into adjacency_list of this node */
+            rb_ary_push(RARRAY(latestAdditionData)->ptr[3], RARRAY(latestAdditionData)->ptr[1]);
+        }
 
-    tmpArray = rb_funcall(queue, rb_intern("data"), 0);
-    for (i = 0; i < RARRAY(tmpArray)->len; i++) {
-        tmpHash = RARRAY(tmpArray)->ptr[i];
-        adjList = rb_hash_aref(tmpHash, ID2SYM(rb_intern("adjacency_list")));
+        for (i = 0; i < RARRAY(RARRAY(latestAdditionData)->ptr[2])->len; i++) {
+            /* grab indexed node */
+            adjacent = RARRAY(nodes)->ptr[FIX2LONG(RARRAY(RARRAY(latestAdditionData)->ptr[2])->ptr[i])];
+            adjacentData = rb_funcall(adjacent, rb_intern("data"), 0);
         
-        for (j = 0; j < RARRAY(adjList)->len; j++)
-            rb_ary_store(adjList, j, RARRAY(tmpArray)->ptr[ FIX2INT(RARRAY(adjList)->ptr[j]) ]);
+            /* check in_q -- only look at new nodes */
+            if (Qtrue == RARRAY(adjacentData)->ptr[4]) {
+
+                /* compare points by node -- adjacent against current */
+                adjacentDistance = rb_funcall(dist_proc,
+                                              rb_intern("call"), 2,
+                                              RARRAY(points)->ptr[FIX2LONG(RARRAY(latestAdditionData)->ptr[0])],
+                                              RARRAY(points)->ptr[FIX2LONG(RARRAY(adjacentData)->ptr[0])]);
+
+                /* If the new distance is better than our current priority, exchange them. */
+                if (RFLOAT(adjacentDistance)->value < RFLOAT(rb_funcall(adjacent, rb_intern("priority"), 0))->value) {
+                    /* set new :parent */
+                    rb_ary_store(adjacentData, 1, latestAddition);
+                    /* update priority */
+                    rb_funcall(adjacent, rb_intern("priority="), 1, adjacentDistance);
+                    /* percolate up into correctn position */
+                    RubyVor_percolate_up(queue, rb_funcall(adjacent, rb_intern("index"), 0));
+                }
+            }
+        }
     }
 
-    latestAddition = rb_funcall(queue, rb_intern("pop"), 0);
-    while (RTEST(latestAddition)) {
-        rb_hash_aset(latestAddition, ID2SYM(rb_intern("in_q")), Qfalse);
+    mst = rb_hash_new();
+    for (i = 0; i < RARRAY(nodes)->len; i++) {
+        latestAddition = RARRAY(nodes)->ptr[i];
+        latestAdditionData = rb_funcall(latestAddition, rb_intern("data"), 0);
+        if (!NIL_P(RARRAY(latestAdditionData)->ptr[1])) {
+            adjacentData = rb_funcall(RARRAY(latestAdditionData)->ptr[1], rb_intern("data"), 0);
+            tmp = rb_ary_new2(2);
+            if (FIX2LONG(RARRAY(latestAdditionData)->ptr[0]) < FIX2LONG(RARRAY(adjacentData)->ptr[0])) {
+                rb_ary_push(tmp, RARRAY(latestAdditionData)->ptr[0]);
+                rb_ary_push(tmp, RARRAY(adjacentData)->ptr[0]);
+            } else {
+                rb_ary_push(tmp, RARRAY(adjacentData)->ptr[0]);                
+                rb_ary_push(tmp, RARRAY(latestAdditionData)->ptr[0]);
+            }
+            if (!RTEST(rb_funcall(mst, rb_intern("has_key?"), 1, tmp))) {
+                rb_hash_aset(mst, tmp, rb_funcall(latestAddition, rb_intern("priority"), 0));
 
-        if (RTEST(rb_hash_aref(latestAddition, ID2SYM(rb_intern("parent"))))) {
+            }
         }
-        break;
     }
+
+    rb_iv_set(self, "@mst", mst);
     
-    return tmpArray;
+    return mst;
 }
-*/
+
 
 VALUE
 RubyVor_nn_graph(VALUE self)
 {
-    long i, j;
+    long i;
     VALUE dtRaw, graph, points, * dtPtr, * tripletPtr, * graphPtr;
 
     graph = rb_iv_get(self, "@nn_graph");
@@ -197,16 +249,17 @@ RubyVor_nn_graph(VALUE self)
     if (RTEST(graph))
         return graph;
 
-    // Create an array of same size as points for the graph
+    /* Create an array of same size as points for the graph */
     points = rb_iv_get(self, "@points");
+    
     graph = rb_ary_new2(RARRAY(points)->len);
     for (i = 0; i < RARRAY(points)->len; i++)
         rb_ary_push(graph, rb_ary_new());
     
-    // Get our pointer into this array.
+    /* Get our pointer into this array. */
     graphPtr = RARRAY(graph)->ptr;
 
-    // Iterate over the triangulation
+    /* Iterate over the triangulation */
     dtRaw = rb_iv_get(self, "@delaunay_triangulation_raw");
     dtPtr = RARRAY(dtRaw)->ptr;
     for (i = 0; i < RARRAY(dtRaw)->len; i++) {
@@ -220,11 +273,12 @@ RubyVor_nn_graph(VALUE self)
 
         rb_ary_push(graphPtr[FIX2INT(tripletPtr[1])], tripletPtr[2]);
         rb_ary_push(graphPtr[FIX2INT(tripletPtr[2])], tripletPtr[1]);
+        
     }
-
     for (i = 0; i < RARRAY(graph)->len; i++) {
         if (RARRAY(graphPtr[i])->len < 1) {
-            // No valid triangles touched this node -- include *all* possible neighbors
+            rb_raise(rb_eIndexError, "index of 0 (no neighbors) at %i", i);
+            /* No valid triangles touched this node -- include *all* possible neighbors
             for(j = 0; j < RARRAY(points)->len; j++) {
                 if (j != i) {
                     rb_ary_push(graphPtr[i], INT2FIX(j));
@@ -232,6 +286,7 @@ RubyVor_nn_graph(VALUE self)
                         rb_ary_push(graphPtr[j], INT2FIX(i));
                 }
             }
+            */
         } else {
             rb_funcall(graphPtr[i], rb_intern("uniq!"), 0);
         }
@@ -244,9 +299,9 @@ RubyVor_nn_graph(VALUE self)
 
 
 
-//
-// Static C helper methods
-//
+/*
+ * Static C helper methods
+ */
 
 
 /*** sort sites on y, then x, coord ***/

data/ext/rb_cPoint.c

@@ -12,3 +12,24 @@ 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)));
 }
+
+VALUE
+RubyVor_point_hash(VALUE self)
+{
+    double x, y;
+    char *c;
+    long i, xHash, yHash;
+
+    x = NUM2DBL(rb_iv_get(self, "@x"));
+    y = NUM2DBL(rb_iv_get(self, "@y"));
+
+    /* Bastardized from Ruby's numeric.c */
+    
+    for (c = (char*)&x, xHash = 0, i = 0; i < sizeof(double); i++) xHash += c[i] * 971;
+    for (c = (char*)&y, yHash = 0, i = 0; i < sizeof(double); i++) yHash += c[i] * 971;
+
+    xHash = xHash & RB_HASH_FILTER;
+    yHash = yHash & RB_HASH_FILTER;
+    
+    return LONG2FIX((xHash << (RB_LONG_BITS / 2)) | yHash);
+}

data/ext/rb_cPriorityQueue.c

@@ -2,9 +2,9 @@
 #include <vdefs.h>
 #include <ruby_vor_c.h>
 
-//
-// Instance methods for RubyVor::VDDT::PriorityQueue
-//
+/*
+ * Instance methods for RubyVor::VDDT::PriorityQueue
+ */
 
 
 static VALUE

data/ext/ruby_vor_c.c

@@ -2,15 +2,15 @@
 #include <vdefs.h>
 #include <ruby_vor_c.h>
 
-//
-// Extension initialization
-//
+/*
+ * Extension initialization
+ */
 void
 Init_ruby_vor_c(void)
 {
-    //
-    // Set up our Modules and Class.
-    //
+    /*
+     * Set up our Modules and Class.
+     */
 
     /*
      * Main RubyVor namespace.
@@ -30,7 +30,7 @@ Init_ruby_vor_c(void)
     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);
+    rb_define_method(RubyVor_rb_cComputation, "minimum_spanning_tree", RubyVor_minimum_spanning_tree, -1);
 
     
     /*
@@ -48,14 +48,15 @@ Init_ruby_vor_c(void)
      */
     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);
+    rb_define_method(RubyVor_rb_cPoint, "hash", RubyVor_point_hash, 0);
 }
 
 
 
 
-//
-// Method declarations duplicated here for RDOC
-//
+/*
+ * Method declarations duplicated here for RDOC
+ */
 
 /*
  * Compute the voronoi diagram and delaunay triangulation from a set of points.
@@ -71,9 +72,11 @@ VALUE RubyVor_from_points(VALUE, VALUE);
 VALUE RubyVor_nn_graph(VALUE);
 
 /*
- * Compute the MST for the nearest-nearest graph using a Priority Queue and Prim's algorithm.
+ * Computes the minimum spanning tree for given points, using the Delaunay triangulation as a seed.
+ *
+ * For points on a Euclidean plane, the MST is always comprised of a subset of the edges in a Delaunay triangulation. This makes computation of the tree very efficient: simply compute the Delaunay triangulation, and then run Prim's algorithm on the resulting edges.
  */
-// VALUE RubyVor_minimum_spanning_tree(int, VALUE*, VALUE);
+VALUE RubyVor_minimum_spanning_tree(int, VALUE*, VALUE);
 
 /*
  * Move from the given index up, restoring the heap-order property.
@@ -95,5 +98,9 @@ VALUE RubyVor_heapify(VALUE);
  */
 VALUE RubyVor_distance_from(VALUE, VALUE);
 
+/*
+ * Hash value for a point.
+ */
+VALUE RubyVor_point_hash(VALUE);
 
-// keep comment so RDOC will find the last method definition
+/* keep comment so RDOC will find the last method definition */