bribera-rubyvor 0.0.2 → 0.1.1

data/test/test_priority_queue.rb

@@ -0,0 +1,129 @@
+require 'rubygems'
+require 'minitest/unit'
+require File.dirname(__FILE__) + '/../lib/ruby_vor'
+
+class TestPriorityQueue < MiniTest::Unit::TestCase
+  
+  def test_heap_order_property
+    # min heap by default
+    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)}
+
+    items.sort!
+    idx = 0
+
+    # Test peek
+    assert_equal q.peek.data, items[0]
+    
+    while min = q.pop
+      # Test pop
+      assert_equal min.data, items[idx]
+
+      # Test peek
+      assert_equal q.peek.data, items[idx + 1] if idx + 1 < items.length
+      
+      idx += 1
+    end
+  end
+
+  def test_heapify
+    q = RubyVor::PriorityQueue.new
+
+    # 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.
+
+    100.times{ q.push(rand * 10000.0 - 5000.0)}
+      
+    # Set things right.
+    q.heapify()
+
+    old_n = -1.0 * Float::MAX
+    while n = q.pop
+      assert n.priority >= old_n, 'Heap-order property violated'
+      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
+
+  def test_build_queue
+    n = 100
+    
+    q = RubyVor::PriorityQueue.build_queue(n) do |queue_item|
+      queue_item.priority = rand * 10000.0 - 5000.0
+    end
+
+    assert_equal n, q.data.length
+    assert_equal n, q.size
+    
+    old_n = -1.0 * Float::MAX
+    while n = q.pop
+      assert n.priority >= old_n, 'Heap-order property violated'
+      old_n = n.priority
+    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

data/test/test_voronoi_interface.rb

@@ -2,24 +2,26 @@ require 'rubygems'
 require 'minitest/unit'
 require File.dirname(__FILE__) + '/../lib/ruby_vor'
 
+
 class TestVoronoiInterface < MiniTest::Unit::TestCase
 
-  MAX_DELTA = 0.000001
-  
   def initialize(*args)
     @points = @trianglulation_raw = @diagram_raw = nil
     super(*args)
   end
+
+  
+  MAX_DELTA = 0.000001
   
   def test_diagram_correct
-    # Perform the decomposition.
-    decomp = RubyVor::VDDT::Decomposition.from_points(sample_points)
+    # Perform the computation.
+    comp = RubyVor::VDDT::Computation.from_points(sample_points)
 
     # Test each raw entry against three basic assertions:
     #  * entry lengths must match
     #  * entry types must match
     #  * entry values must match, with allowance for rounding errors (i.e. within a very small delta)
-    decomp.voronoi_diagram_raw.each_with_index do |computed_entry, i|
+    comp.voronoi_diagram_raw.each_with_index do |computed_entry, i|
       sample_entry = example_diagram_raw[i]
 
       
@@ -36,15 +38,15 @@ class TestVoronoiInterface < MiniTest::Unit::TestCase
   
 
   def test_triangulation_correct
-    # Perform the decomposition.
-    decomp = RubyVor::VDDT::Decomposition.from_points(sample_points)
+    # Perform the computation.
+    comp = RubyVor::VDDT::Computation.from_points(sample_points)
 
     # One assertion:
     #  * raw triangulation must match exactly.
     
-    assert_equal example_triangulation_raw, decomp.delaunay_triangulation_raw
+    assert_equal example_triangulation_raw, comp.delaunay_triangulation_raw
   end
-  
+
 
   
   #
@@ -153,6 +155,7 @@ class TestVoronoiInterface < MiniTest::Unit::TestCase
     end
     @trianglulation_raw
   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.2
+  version: 0.1.1
 platform: ruby
 authors: 
 - Brendan Ribera
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-12-03 00:00:00 -08:00
+date: 2009-01-15 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -44,14 +44,24 @@ files:
 - 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.c
+- ext/ruby_vor_c.h
 - ext/vdefs.h
 - ext/voronoi.c
-- ext/voronoi_interface.c
 - lib/ruby_vor.rb
-- lib/ruby_vor/decomposition.rb
+- lib/ruby_vor/computation.rb
+- 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_point.rb
+- test/test_priority_queue.rb
 - test/test_voronoi_interface.rb
 has_rdoc: true
 homepage: http://github.com/bribera/rubyvor
@@ -82,4 +92,7 @@ signing_key:
 specification_version: 2
 summary: RubyVor provides efficient computation of Voronoi diagrams and Delaunay triangulation for a set of Ruby points
 test_files: 
+- test/test_computation.rb
+- test/test_priority_queue.rb
 - test/test_voronoi_interface.rb
+- test/test_point.rb

data/ext/voronoi_interface.c

@@ -1,213 +0,0 @@
-#include <ruby.h>
-#include <vdefs.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-
-
-
-VoronoiState rubyvorState;
-
-static VALUE rb_mRubyVor;
-static VALUE rb_mVDDT;
-static VALUE rb_cDecomposition;
-static int repeat, rit;
-
-// Static method definitions
-static VALUE from_points(VALUE, VALUE);
-
-static Site * readone(void), * nextone(void);
-static int scomp(const void *, const void *);
-
-
-
-void
-Init_voronoi_interface(void)
-{
-    // Set up our Modules and Class.
-    rb_mRubyVor       = rb_define_module("RubyVor");
-    rb_mVDDT          = rb_define_module_under(rb_mRubyVor, "VDDT");
-    rb_cDecomposition = rb_define_class_under(rb_mVDDT, "Decomposition", rb_cObject);
-
-    // Add methods.
-    rb_define_singleton_method(rb_cDecomposition, "from_points", from_points, 1);
-}
-
-
-//
-// Class methods
-//
-static VALUE
-from_points(VALUE self, VALUE pointsArray)
-{
-    //VALUE returnValue;
-    VALUE * inPtr, newDecomp;
-    ID x, y;
-
-    long i, inSize;
-
-    // TODO: remove
-    repeat = 1;
-    
-    for (rit = 0; rit < repeat; rit++) {
-
-    // Require T_ARRAY
-    Check_Type(pointsArray, T_ARRAY);
-
-    // 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)
-        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))
-            rb_raise(rb_eRuntimeError, "members of points array must respond to 'x' and 'y'");
-    }
-
-    
-    // Initialize rubyvorState
-    initialize_state(0/* debug? */);
-    
-    // Create our return object.
-    newDecomp = rb_funcall(self, rb_intern("new"), 0);
-    // Store it in rubyvorState so we can populate its values.
-    rubyvorState.decomp = (void *) &newDecomp;
-
-
-    //
-    // 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));
-    
-    
-        // 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)
-            {
-                rubyvorState.sites = (Site *)myrealloc(rubyvorState.sites,(rubyvorState.nsites+4000)*sizeof(Site),rubyvorState.nsites*sizeof(Site));
-            }
-        }
-        
-        // Sort the Sites
-        qsort((void *)rubyvorState.sites, rubyvorState.nsites, sizeof(Site), scomp) ;
-        
-        // 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)
-        {
-            if (rubyvorState.sites[i].coord.x < rubyvorState.xmin)
-            {
-                rubyvorState.xmin = rubyvorState.sites[i].coord.x;
-            }
-            if (rubyvorState.sites[i].coord.x > rubyvorState.xmax)
-            {
-                rubyvorState.xmax = rubyvorState.sites[i].coord.x;
-            }
-        }
-        rubyvorState.ymin = rubyvorState.sites[0].coord.y;
-        rubyvorState.ymax = rubyvorState.sites[rubyvorState.nsites-1].coord.y;
-        
-    }    
-
-    
-    // Perform the computation
-    voronoi(nextone);
-    
-    // Free our allocated objects
-    free_all();
-
-    if (rubyvorState.debug)
-        fprintf(stderr,"FINISHED ITERATION %i\n", repeat + 1);
-
-    
-    }
-    
-    return newDecomp;
-}
-
-
-
-
-//
-// Static C methods
-//
-
-/*** sort sites on y, then x, coord ***/
-static int
-scomp(const void * vs1, const void * vs2)
-{
-    Point * s1 = (Point *)vs1 ;
-    Point * s2 = (Point *)vs2 ;
-
-    if (s1->y < s2->y)
-    {
-        return (-1) ;
-    }
-    if (s1->y > s2->y)
-    {
-        return (1) ;
-    }
-    if (s1->x < s2->x)
-    {
-        return (-1) ;
-    }
-    if (s1->x > s2->x)
-    {
-        return (1) ;
-    }
-    return (0) ;
-}
-
-/*** return a single in-storage site ***/
-static Site *
-nextone(void)
-{
-    Site * s ;
-
-    if (rubyvorState.siteidx < rubyvorState.nsites)
-    {
-        s = &rubyvorState.sites[rubyvorState.siteidx++];
-        return (s) ;
-    }
-    else
-    {
-        return ((Site *)NULL) ;
-    }
-}
-
-
-/*** read one site ***/
-static Site *
-readone(void)
-{
-    Site * s ;
-
-    s = (Site *)getfree(&(rubyvorState.sfl)) ;
-    s->refcnt = 0 ;
-    s->sitenbr = rubyvorState.siteidx++ ;
-    if (scanf("%f %f", &(s->coord.x), &(s->coord.y)) == EOF)
-    {
-        return ((Site *)NULL ) ;
-    }
-    return (s) ;
-}