rubyvor 0.1.3

data/test/test_point.rb

@@ -0,0 +1,100 @@
+require 'rubygems'
+require 'minitest/unit'
+require File.dirname(__FILE__) + '/../lib/ruby_vor'
+
+class TestPoint < MiniTest::Unit::TestCase
+
+  def test_instantiation
+    a = b = nil
+    
+    assert_raises TypeError do
+      a = RubyVor::Point.new(:"10", 10)
+    end
+    
+    assert_raises TypeError do
+      a = RubyVor::Point.new(10, :"10")
+    end
+    
+    assert_nothing_raised do
+      a = RubyVor::Point.new(123.456, 789.10)
+      b = RubyVor::Point.new("123.456", "789.10")
+    end
+
+    assert_equal a, b
+  end
+  
+  def test_comparison
+    a = RubyVor::Point.new(10, 10)
+    b = RubyVor::Point.new(1,  1)
+
+    assert a > b
+    assert b < a
+    assert_equal(-1, (b <=> a))
+  end
+
+  def test_equality
+    a = RubyVor::Point.new(10,   10)
+    b = RubyVor::Point.new(10.0, 10)
+    c = RubyVor::Point.new(10.0, 10.0)
+    d = RubyVor::Point.new(10,   10.0)
+    
+    z = RubyVor::Point.new(Math::PI, Math::PI)
+    o = a
+
+    
+    # Test equality of values; both == and eql? perform this function.
+    assert a == a
+    assert a == b
+    assert a == c
+    assert a == d
+    assert a == o
+    assert a.eql?(a)
+    assert a.eql?(b)
+    assert a.eql?(c)
+    assert a.eql?(d)
+    assert a.eql?(o)
+    
+    refute a == z
+    refute a.eql?(z)
+    
+
+    # Test object equality.
+    refute a.equal?(b)
+    refute a.equal?(c)
+    refute a.equal?(d)
+    refute a.equal?(z)
+    
+    assert a.equal?(a)
+    assert a.equal?(o)
+  end
+
+  def test_hash
+    a = RubyVor::Point.new(10,   10)
+    b = RubyVor::Point.new(10.0, 10)
+    c = RubyVor::Point.new(10.0, 10.0)
+    d = RubyVor::Point.new(10,   10.0)
+    
+    z = RubyVor::Point.new(Math::PI, Math::PI)
+    o = a
+
+    assert_equal a.hash, b.hash
+    assert_equal a.hash, c.hash
+    assert_equal a.hash, d.hash
+    assert_equal a.hash, o.hash
+
+    refute_equal a.hash, z.hash
+  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

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

@@ -0,0 +1,161 @@
+require 'rubygems'
+require 'minitest/unit'
+require File.dirname(__FILE__) + '/../lib/ruby_vor'
+
+
+class TestVoronoiInterface < MiniTest::Unit::TestCase
+
+  def initialize(*args)
+    @points = @trianglulation_raw = @diagram_raw = nil
+    super(*args)
+  end
+
+  
+  MAX_DELTA = 0.000001
+  
+  def test_diagram_correct
+    # 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)
+    comp.voronoi_diagram_raw.each_with_index do |computed_entry, i|
+      sample_entry = example_diagram_raw[i]
+
+      
+      assert_equal computed_entry.length, sample_entry.length
+      assert_equal computed_entry.first,  sample_entry.first
+      
+      computed_entry.each_with_index do |computed_value,j|    
+        # We already tested the type...
+        next if j == 0
+        assert_in_delta computed_value, sample_entry[j], MAX_DELTA
+      end
+    end
+  end
+  
+
+  def test_triangulation_correct
+    # Perform the computation.
+    comp = RubyVor::VDDT::Computation.from_points(sample_points)
+
+    # One assertion:
+    #  * raw triangulation must match exactly.
+    
+    assert_equal example_triangulation_raw, comp.delaunay_triangulation_raw
+  end
+
+
+  
+  #
+  # A few helper methods
+  #
+  
+  private
+  
+  def sample_points
+    # Build a sample case
+    if @points.nil? || @points.empty?
+      @points = []
+      data = %w{ 0.0 0.0
+                 0.0 0.5
+                 0.5 0.0
+                 3   3
+                 0.5 0.5
+                 5.0 5.0
+                 5.0 5.5
+                 5.5 5.0
+                 5.5 5.5 }
+      for x in 0..(data.length/2 - 1)
+        @points << RubyVor::Point.new(data[x * 2].to_f, data[x * 2 + 1].to_f)
+      end
+    end
+    @points
+  end
+
+  def example_diagram_raw
+    if @diagram_raw.nil? || @diagram_raw.empty?
+      @diagram_raw = [
+                      [:s, 0.000000, 0.000000],
+                      [:s, 0.500000, 0.000000],
+                      [:l, 1.000000, 0.000000, 0.250000],
+                      [:s, 0.000000, 0.500000],
+                      [:l, 0.000000, 1.000000, 0.250000],
+                      [:s, 0.500000, 0.500000],
+                      [:l, 0.000000, 1.000000, 0.250000],
+                      [:v, 0.250000, 0.250000],
+                      [:l, 1.000000, 1.000000, 0.500000],
+                      [:v, 0.250000, 0.250000],
+                      [:e, 3, 1, 0],
+                      [:l, 1.000000, 0.000000, 0.250000],
+                      [:s, 3.000000, 3.000000],
+                      [:l, 1.000000, 1.000000, 3.500000],
+                      [:v, 3.250000, 0.250000],
+                      [:e, 2, 0, 2],
+                      [:l, 0.833333, 1.000000, 2.958333],
+                      [:s, 5.000000, 5.000000],
+                      [:l, 1.000000, 1.000000, 8.000000],
+                      [:s, 5.500000, 5.000000],
+                      [:l, 1.000000, 0.800000, 7.450000],
+                      [:v, 5.249999, 2.750001],
+                      [:l, 1.000000, 0.000000, 5.250000],
+                      [:s, 5.000000, 5.500000],
+                      [:l, 0.000000, 1.000000, 5.250000],
+                      [:s, 5.500000, 5.500000],
+                      [:l, 0.000000, 1.000000, 5.250000],
+                      [:v, 5.250000, 5.250000],
+                      [:e, 9, 4, 3],
+                      [:l, 1.000000, 1.000000, 10.500000],
+                      [:v, 5.250000, 5.250000],
+                      [:e, 12, 5, 4],
+                      [:l, 1.000000, 0.000000, 5.250000],
+                      [:v, 0.250000, 3.250000],
+                      [:e, 4, 6, 1],
+                      [:e, 5, 6, 2],
+                      [:l, 1.000000, 0.833333, 2.958333],
+                      [:v, 2.750000, 5.250000],
+                      [:e, 7, 7, 3],
+                      [:e, 10, 7, 5],
+                      [:l, 0.800000, 1.000000, 7.450000],
+                      [:v, 15.249999, -9.749999],
+                      [:e, 8, 3, 8],
+                      [:e, 6, 2, 8],
+                      [:l, 1.000000, 1.000000, 5.500000],
+                      [:v, -9.749999, 15.249999],
+                      [:e, 14, 9, 6],
+                      [:e, 15, 9, 7],
+                      [:l, 1.000000, 1.000000, 5.500000],
+                      [:e, 1, -1, 1],
+                      [:e, 17, -1, 9],
+                      [:e, 13, -1, 5],
+                      [:e, 11, 4, -1],
+                      [:e, 16, 8, -1],
+                      [:e, 0, 0, -1]
+                     ]
+    end
+    @diagram_raw
+  end
+
+  def example_triangulation_raw
+    if @trianglulation_raw.nil? || @trianglulation_raw.empty?
+      @trianglulation_raw =     [
+                                 [0, 4, 2],
+                                 [1, 4, 0],
+                                 [3, 2, 4],
+                                 [5, 7, 3],
+                                 [5, 8, 7],
+                                 [6, 8, 5],
+                                 [1, 3, 4],
+                                 [3, 6, 5],
+                                 [7, 2, 3],
+                                 [1, 6, 3]
+                                ]
+    end
+    @trianglulation_raw
+  end
+  
+end
+
+MiniTest::Unit.autorun

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification 
+name: rubyvor
+version: !ruby/object:Gem::Version 
+  version: 0.1.3
+platform: ruby
+authors: 
+- Brendan Ribera
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-26 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.4.0
+    version: 
+description: 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.
+email: 
+- brendan.ribera+rubyvor@gmail.com
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: 
+- Manifest.txt
+files: 
+- History.rdoc
+- Manifest.txt
+- README.rdoc
+- 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.c
+- ext/ruby_vor_c.h
+- ext/vdefs.h
+- ext/voronoi.c
+- lib/ruby_vor.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
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: rubyvor
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Efficient Voronoi diagrams and Delaunay trianglation for Ruby
+test_files: 
+- test/test_computation.rb
+- test/test_point.rb
+- test/test_priority_queue.rb
+- test/test_voronoi_interface.rb