rubyvor 0.1.3

data/lib/ruby_vor/priority_queue.rb

@@ -0,0 +1,87 @@
+module RubyVor
+  class PriorityQueue
+
+    attr_reader :data, :size
+
+    class << self
+      def build_queue(max_index=-1,&block)
+        data = []
+
+        index = 0
+        loop do
+          x = QueueItem.new(nil, nil, nil)
+
+          yield(x)
+          break if !(max_index < 0 || index < max_index) || x.priority.nil?
+          
+          x.index = index
+          data.push(x)
+          index += 1
+        end
+
+        q = new
+        q.instance_variable_set(:@data, data)
+        q.instance_variable_set(:@size, data.length)
+        q.heapify()
+
+        return q
+      end
+    end
+    
+    def initialize
+      @data = []
+      @size = 0
+      heapify()
+    end
+
+    def peek
+      @data[0]
+    end
+
+    def pop
+      return nil if @size < 1
+      
+      r = @data[0]
+
+      @data[0] = @data[@size-1]
+      @data[0].index = 0
+      @data.delete_at(@size-1)
+
+      @size -= 1
+      
+      percolate_down(0) if @size > 0
+
+      return r
+    end
+
+    def push(data, priority=data)
+      @size += 1
+      @data[@size - 1] = QueueItem.new(priority, @size - 1, data)
+      percolate_up(@size - 1)
+    end
+
+    # Implemented in C
+    def reorder_queue;end
+
+    protected
+
+    # Implemented in C
+    # def heapify(data);end
+
+    # Implemented in C
+    # def percolate_up(i);end
+
+    # Implemented in C
+    # def percolate_down(i);end
+
+    class QueueItem
+      attr_accessor :priority, :index, :data
+      def initialize(p, i, d)
+        @priority = p
+        @index    = i
+        @data     = d
+      end
+    end
+    
+  end
+end

data/lib/ruby_vor/version.rb

@@ -0,0 +1,3 @@
+module RubyVor
+  VERSION = '0.1.3'
+end

data/lib/ruby_vor/visualizer.rb

@@ -0,0 +1,218 @@
+require 'xml/libxml' unless defined?(LibXML)
+module RubyVor
+  class Visualizer
+
+    COLORS = %w{black red blue lime gray yellow purple orange pink}
+
+    # Support various versions of LibXML
+    include LibXML if defined?(LibXML)
+      
+    def self.make_svg(computation, opts={})
+      @opts = opts = {
+        :name            => 'vddt.svg',
+        :triangulation   => true,
+        :voronoi_diagram => false,
+        :mst             => false,
+        :cbd             => false,
+      }.merge(opts)
+
+      line_colors = COLORS.clone
+      
+      doc = XML::Document.new()
+      
+      doc.root = XML::Node.new('svg')
+      doc.root['xmlns'] = 'http://www.w3.org/2000/svg'
+      doc.root['xml:space'] = 'preserve'
+
+      max_x = 0
+      min_x = Float::MAX
+      max_y = 0
+      min_y = Float::MAX
+      pmax_x = 0
+      pmin_x = Float::MAX
+      pmax_y = 0
+      pmin_y = Float::MAX
+
+      computation.points.each do |point|
+        max_x = point.x if point.x > max_x
+        min_x = point.x if point.x < min_x
+        max_y = point.y if point.y > max_y
+        min_y = point.y if point.y < min_y
+        pmax_x = point.x if point.x > pmax_x
+        pmin_x = point.x if point.x < pmin_x
+        pmax_y = point.y if point.y > pmax_y
+        pmin_y = point.y if point.y < pmin_y
+      end
+
+      if opts[:voronoi_diagram]
+        computation.voronoi_diagram_raw.each do |item|
+          if item.first == :v
+            max_x = item[1] if item[1] > max_x
+            min_x = item[1] if item[1] < min_x
+            max_y = item[2] if item[2] > max_y
+            min_y = item[2] if item[2] < min_y
+          end
+        end
+      end
+      
+      opts[:offset_x] = -1.0 * min_x + 20
+      opts[:offset_y] = -1.0 * min_y + 20
+
+      if opts[:triangulation]
+        # Draw in the triangulation
+        color = line_colors.shift
+        computation.delaunay_triangulation_raw.each do |triplet|
+          for i in 0..2
+            line = line_from_points(computation.points[triplet[i % 2 + 1]], computation.points[triplet[i & 6]])
+            line['style'] = "stroke:#{color};stroke-width:1;"            
+            doc.root << line
+          end
+        end
+      end
+
+      if opts[:mst]
+        color = line_colors.shift
+        computation.minimum_spanning_tree.each do |edge, weight|
+          line = line_from_points(computation.points[edge[0]], computation.points[edge[1]])
+          line['style'] = "stroke:#{color};stroke-width:1;"
+          doc.root << line
+        end
+      end
+
+      if opts[:cbd]
+        mst = computation.minimum_spanning_tree
+        
+        computation.cluster_by_distance(opts[:cbd]).each do |cluster|
+          
+          color = new_color
+          min_dist = Float::MAX
+          set_min  = false
+          cluster.each do |a|
+            cluster.each do |b|
+              next if a == b
+              k = a < b ? [a,b] : [b,a]
+              next unless mst.has_key?(k)
+
+              if mst[k] < min_dist
+                min_dist = mst[k]
+                set_min = true
+              end
+            end
+          end
+
+          min_dist = 10 unless set_min
+
+
+          cluster.each do |v|
+            node = circle_from_point(computation.points[v])
+            node['r'] = (min_dist + 10).to_s
+            node['style'] = "fill:#{color};stroke:#{color};"
+            node['opacity'] = '0.4'
+
+            doc.root << node
+          end
+
+        end
+      end
+
+      if opts[:voronoi_diagram]
+        voronoi_vertices = []
+        draw_lines = []
+        draw_points = []
+        line_functions = []
+        
+        xcut = (pmax_x + pmin_x) / 2.0
+        ycut = (pmax_y + pmin_y) / 2.0
+
+        color = line_colors.shift
+
+        computation.voronoi_diagram_raw.each do |item|
+          case item.first
+          when :v
+            # Draw a voronoi vertex
+            v = RubyVor::Point.new(item[1], item[2])
+            voronoi_vertices.push(v)
+            node = circle_from_point(v)
+            node['fill'] = 'red'
+            node['r'] = '2'
+            node['stroke'] = 'black'
+            node['stroke-width'] = '1'
+
+            draw_points << node
+          when :l
+            # :l a b c  --> ax + by = c
+            a = item[1]
+            b = item[2]
+            c = item[3]
+            line_functions.push({ :y => lambda{|x| (c - a * x) / b},
+                                  :x => lambda{|y| (c - b * y) / a} })
+          when :e
+            if item[2] == -1 || item[3] == -1
+              from_vertex = voronoi_vertices[item[2] == -1 ? item[3] : item[2]]
+              
+              next if from_vertex < RubyVor::Point.new(0,0)              
+
+              if item[2] == -1
+                inf_vertex = RubyVor::Point.new(0, line_functions[item[1]][:y][0])
+              else
+                inf_vertex = RubyVor::Point.new(max_x, line_functions[item[1]][:y][max_x])
+              end
+
+              line = line_from_points(from_vertex, inf_vertex)
+            else
+              line = line_from_points(voronoi_vertices[item[2]], voronoi_vertices[item[3]])
+            end
+
+            line['style'] = "stroke:#{color};stroke-width:1;"
+            draw_lines << line
+
+          end
+        end
+
+        draw_lines.each {|l| doc.root << l}
+        draw_points.each {|p| doc.root << p}
+      end
+      
+      # Now draw in nodes
+      computation.points.each do |point|
+        node = circle_from_point(point)
+        node['fill'] = 'lime'
+
+        doc.root << node
+      end
+
+      doc.root['width']  = (max_x + opts[:offset_x] + 50).to_s
+      doc.root['height'] = (max_y + opts[:offset_y] + 50).to_s
+      
+      doc.save(opts[:name] || 'vddt.svg')
+    end
+    
+    private
+    def self.line_from_points(a, b)
+      line = XML::Node.new('line')
+      line['x1'] = (a.x + @opts[:offset_x] + 10).to_s
+      line['y1'] = (a.y + @opts[:offset_y] + 10).to_s
+      line['x2'] = (b.x + @opts[:offset_x] + 10).to_s
+      line['y2'] = (b.y + @opts[:offset_y] + 10).to_s
+      line
+    end
+    
+    def self.circle_from_point(point)
+      node = XML::Node.new('circle')
+      node['cx'] = (point.x + @opts[:offset_x] + 10).to_s
+      node['cy'] = (point.y + @opts[:offset_y] + 10).to_s
+      node['r'] = 5.to_s
+      node['stroke'] = 'black'
+      node['stroke-width'] = 2.to_s
+      node
+    end
+
+    def self.new_color
+      a = rand(256)
+      b = rand(256) | a
+      c = rand(256) ^ b
+      
+      "rgb(#{[a,b,c].sort{|k,l| rand(3)-1}.join(',')})"
+    end
+  end
+end

data/rubyvor.gemspec

@@ -0,0 +1,35 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{rubyvor}
+  s.version = "0.1.3"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Brendan Ribera"]
+  s.date = %q{2010-01-26}
+  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 = ["Manifest.txt"]
+  s.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"]
+  s.homepage = %q{http://github.com/bribera/rubyvor}
+  s.rdoc_options = ["--main", "README.rdoc"]
+  s.require_paths = ["lib", "ext"]
+  s.rubyforge_project = %q{rubyvor}
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Efficient Voronoi diagrams and Delaunay trianglation for Ruby}
+  s.test_files = ["test/test_computation.rb", "test/test_point.rb", "test/test_priority_queue.rb", "test/test_voronoi_interface.rb"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<hoe>, [">= 2.4.0"])
+    else
+      s.add_dependency(%q<hoe>, [">= 2.4.0"])
+    end
+  else
+    s.add_dependency(%q<hoe>, [">= 2.4.0"])
+  end
+end

data/test/test_computation.rb

@@ -0,0 +1,354 @@
+require 'rubygems'
+require 'minitest/unit'
+require File.dirname(__FILE__) + '/../lib/ruby_vor'
+
+class TestComputation < MiniTest::Unit::TestCase
+
+  def initialize(*args)
+    @points = @trianglulation_raw = @diagram_raw = nil
+    super(*args)
+  end
+
+  def test_empty_points
+    assert_raises TypeError do
+      RubyVor::VDDT::Computation.from_points(nil)
+    end
+    
+    assert_raises RuntimeError do
+      RubyVor::VDDT::Computation.from_points([])
+    end
+  end
+
+  def test_nn_graph
+    comp = RubyVor::VDDT::Computation.from_points(sample_points)
+    
+    # based on this expected delaunay trianglulation:
+    #    3 2 1
+    #    3 0 2
+    #    8 2 0
+    #    3 8 0
+    #    5 6 8
+    #    7 6 5
+    #    7 4 6
+    #    6 2 8
+    #    8 7 5
+    
+    expected_graph = [
+                      [2, 3, 8],          # 0
+                      [2, 3],             # 1
+                      [0, 1, 3, 6, 8],    # 2
+                      [0, 1, 2, 8],       # 3
+                      [6, 7],             # 4
+                      [6, 7, 8],          # 5
+                      [2, 4, 5, 7, 8],    # 6
+                      [4, 5, 6, 8],       # 7
+                      [0, 2, 3, 5, 6, 7], # 8
+                     ]
+
+
+    comp.nn_graph.each_with_index do |neighbors,i|
+      refute_empty neighbors, "@nn_graph returned empty neighbors for node #{i}"
+    end
+
+    assert_equal comp.nn_graph.map{|v| v.sort}.sort, \
+                 expected_graph.map{|v| v.sort}.sort
+  end
+
+  def test_simple_mst
+    points = [
+              RubyVor::Point.new(0,0),
+              RubyVor::Point.new(1.0,1.1),
+              RubyVor::Point.new(4.9,3.1),
+             ]
+
+    comp = RubyVor::VDDT::Computation.from_points(points)
+    expected_mst = [
+                    [0,1],
+                    [1,2]
+                   ]
+    computed_mst = comp.minimum_spanning_tree
+    
+    # Assert nodes are correct
+    assert_equal expected_mst.sort, \
+                 computed_mst.keys.sort
+  end
+  
+  def test_advanced_mst
+    # Test tree taken from an example SVG included in the Wikipedia article on Euclidean minimum spanning trees:
+    # http://en.wikipedia.org/wiki/Image:Euclidean_minimum_spanning_tree.svg
+    
+    points = [
+              RubyVor::Point.new(155.692, 99.783),  # 0
+              RubyVor::Point.new(162.285, 120.245), # 1
+              RubyVor::Point.new(143.692, 129.893), # 2
+              RubyVor::Point.new(150.128, 167.924), # 3
+              RubyVor::Point.new(137.617, 188.953), # 4
+              RubyVor::Point.new(193.467, 119.345), # 5
+              RubyVor::Point.new(196.754, 88.47),   # 6
+              RubyVor::Point.new(241.629, 70.845),  # 7
+              RubyVor::Point.new(262.692, 59.97),   # 8
+              RubyVor::Point.new(269.629, 63.158),  # 9
+              RubyVor::Point.new(247.257, 200.669), # 10
+              RubyVor::Point.new(231.28, 245.974),  # 11
+              RubyVor::Point.new(268.002, 264.693), # 12
+              RubyVor::Point.new(155.442, 64.473),  # 13
+              RubyVor::Point.new(198.598, 31.804),  # 14
+              RubyVor::Point.new(216.816, 3.513),   # 15
+              RubyVor::Point.new(89.624, 27.344),   # 16
+              RubyVor::Point.new(67.925, 56.999),   # 17
+              RubyVor::Point.new(77.328, 93.404),   # 18
+              RubyVor::Point.new(65.525, 158.783),  # 19
+              RubyVor::Point.new(63.525,170.783),   # 20
+              RubyVor::Point.new(15.192, 192.783),  # 21
+              RubyVor::Point.new(7.025, 236.949),   # 22
+              RubyVor::Point.new(40.525, 262.949),  # 23
+              RubyVor::Point.new(61.692, 225.95)    # 24
+             ]
+    
+    comp = RubyVor::VDDT::Computation.from_points(points)
+
+    expected_mst = [
+                    [0,1],
+                    [0,13],
+                    [1,2],
+                    [1,5],
+                    [2,3],
+                    [3,4],
+                    [5,6],
+                    [5,10],
+                    [6,7],
+                    [7,8],
+                    [8,9],
+                    [10,11],
+                    [11,12],
+                    [13,14],
+                    [13,16],
+                    [14,15],
+                    [16,17],
+                    [17,18],
+                    [18,19],
+                    [19,20],
+                    [20,21],
+                    [21,22],
+                    [22,23],
+                    [23,24]
+                   ]
+    computed_mst = comp.minimum_spanning_tree
+    
+    assert_equal expected_mst.sort, \
+                 computed_mst.keys.sort
+  end
+  
+  def test_cluster_by_distance
+    comp = RubyVor::VDDT::Computation.from_points(sample_points)
+    
+    expected_clusters = [
+                         [0,1,2,3],
+                         [8],
+                         [4,5,6,7]
+                        ]
+
+    # We want to ensure that the nn_graph isn't modified by this call
+    original_nn_graph = comp.nn_graph.map{|v| v.clone}
+
+    # Compute clusters within a distance of 10
+    computed_clusters = comp.cluster_by_distance(10)
+    
+    assert_equal expected_clusters.map{|cl| cl.sort}.sort, \
+                 computed_clusters.map{|cl| cl.sort}.sort
+
+    assert_equal original_nn_graph, \
+                 comp.nn_graph
+
+  end
+
+  
+  def test_duplicate_points
+    comp = RubyVor::VDDT::Computation.from_points([
+                                                   RubyVor::Point.new(2,3),      # 0
+                                                   RubyVor::Point.new(1,1),      # 1
+                                                   RubyVor::Point.new(1,1),      # 2
+                                                   RubyVor::Point.new(1,1),      # 3
+                                                   RubyVor::Point.new(1,1),      # 4
+                                                   RubyVor::Point.new(1,1),      # 5
+                                                   RubyVor::Point.new(1,1),      # 6
+                                                   RubyVor::Point.new(1,1),      # 7
+                                                   RubyVor::Point.new(1,1),      # 8
+                                                   RubyVor::Point.new(4,10),     # 9
+                                                   RubyVor::Point.new(4,10.0),   # 10
+                                                   RubyVor::Point.new(4.0,10.0), # 11
+                                                   RubyVor::Point.new(4.0,10.0), # 12
+                                                  ])
+    comp.nn_graph.each_with_index do |neighbors,i|
+      refute_empty neighbors, "@nn_graph has empty neighbors for node #{i}"
+    end
+
+=begin
+    assert_equal [[0], [1,2,3,4,5,6,7,8], [9,10,11,12]], \
+                 comp.cluster_by_distance(1).map{|cl| cl.sort}.sort, \
+                 "cluster by distance 1"
+    
+    assert_equal [[0,1,2,3,4,5,6,7,8], [9,10,11,12]], \
+                 comp.cluster_by_distance(5).map{|cl| cl.sort}.sort, \
+                 "cluster by distance 5"
+
+    assert_equal [[0,1,2,3,4,5,6,7,8,9,10,11,12]], \
+                 comp.cluster_by_distance(10).map{|cl| cl.sort}.sort, \
+                 "cluster by distance 10"
+    
+    assert_equal [[0,1,2,3,4,5,6,7,8], [9,10,11,12]], \
+                 comp.cluster_by_size([2])[2].map{|cl| cl.sort}.sort, \
+                 "cluster by size 2"
+=end
+
+    assert_equal [[0], [1], [2]], \
+                 comp.cluster_by_distance(1).map{|cl| cl.sort}.sort, \
+                 "cluster by distance 1"
+    
+    assert_equal [[0,1], [2]], \
+                 comp.cluster_by_distance(5).map{|cl| cl.sort}.sort, \
+                 "cluster by distance 5"
+
+    assert_equal [[0,1,2]], \
+                 comp.cluster_by_distance(10).map{|cl| cl.sort}.sort, \
+                 "cluster by distance 10"
+    
+    assert_equal [[0,1], [2]], \
+                 comp.cluster_by_size([2])[2].map{|cl| cl.sort}.sort, \
+                 "cluster by size 2"
+
+  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
+
+
+  def test_no_neighbors
+    nn_graph = nil
+
+    # Test :raise
+    comp = RubyVor::VDDT::Computation.from_points([1,2,3,4,5].map{|xy| RubyVor::Point.new(xy,xy)})
+    comp.no_neighbor_response = :raise
+
+    assert_equal comp.no_neighbor_response, :raise    
+    assert_raises(IndexError) { nn_graph = comp.nn_graph }
+    assert_raises(IndexError) { comp.cluster_by_distance(5) }
+    assert_equal nn_graph, nil
+
+    
+    # Test :use_all (default)
+    comp = RubyVor::VDDT::Computation.from_points([1,2,3,4,5].map{|xy| RubyVor::Point.new(xy,xy)})
+    comp.no_neighbor_response = :use_all
+
+    assert_equal comp.no_neighbor_response, :use_all
+    assert_nothing_raised { nn_graph = comp.nn_graph }
+    assert_nothing_raised do
+      assert_equal comp.cluster_by_distance(5).map{|a| a.sort}.sort, [[0,1,2,3,4]]
+    end
+    refute_equal nn_graph, nil
+
+    
+    # Test :ignore
+    comp = RubyVor::VDDT::Computation.from_points([1,2,3,4,5].map{|xy| RubyVor::Point.new(xy,xy)})
+    comp.no_neighbor_response = :ignore
+
+    assert_equal comp.no_neighbor_response, :ignore
+    assert_nothing_raised { nn_graph = comp.nn_graph }
+    assert_nothing_raised do
+      assert_equal comp.cluster_by_distance(5).map{|a| a.sort}.sort, [[0],[1],[2],[3],[4]]
+    end
+    refute_equal nn_graph, nil
+  end
+
+  
+  def test_cluster_by_size
+    comp = RubyVor::VDDT::Computation.from_points([
+                                                   RubyVor::Point.new(0.25, 0.25),   # 0
+                                                   RubyVor::Point.new(1, 0.25),      # 1
+                                                   RubyVor::Point.new(0.5, 1),       # 2
+                                                   RubyVor::Point.new(5, 5),         # 3
+                                                   RubyVor::Point.new(10.25, 10.25), # 4
+                                                   RubyVor::Point.new(13, 9),        # 5
+                                                   RubyVor::Point.new(9, 9)          # 6
+                                                  ])
+
+    sizes = [1, 3, 5, 7]
+    
+    computed_sized_clusters = comp.cluster_by_size(sizes)
+
+    # Check that we got clusters for each size requested
+    assert_equal sizes, \
+                 computed_sized_clusters.keys.sort                 
+
+    assert_equal [[0,1,2,3,4,5,6]], \
+                 computed_sized_clusters[1].map{|cl| cl.sort}.sort, \
+                 'Failed cluster of size 1'
+    
+    assert_equal [[0,1,2], [3], [4,5,6]], \
+                 computed_sized_clusters[3].map{|cl| cl.sort}.sort
+
+    assert_equal [[0,1,2], [3], [4], [5], [6]], \
+                 computed_sized_clusters[5].map{|cl| cl.sort}.sort
+
+    assert_equal [[0], [1], [2], [3], [4], [5], [6]], \
+                 computed_sized_clusters[7].sort
+  end
+
+  #
+  # A few helper methods
+  #
+
+  private
+
+  def sample_points
+    if @points.nil?
+      @points = [
+                 [1.1,1],
+                 [0,0],
+                 [1,0],
+                 [0,1.1],
+                 
+                 [101.1,101],
+                 [100,100],
+                 [101,100],
+                 [100,101.1],
+
+                 [43, 55]
+                ].map{|x,y| RubyVor::Point.new(x,y)}
+    end
+    @points
+  end
+  
+  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