gene 0.0.1 → 0.1.0

data/test/unit/gene_test.rb

@@ -0,0 +1,76 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper.rb")
+
+class GeneTest < Test::Unit::TestCase
+  def setup
+    Petri.stubs(:image_dimensions).returns(Point.new(640, 480))
+    Petri.stubs(:num_points).returns(3)
+
+    @gene = Gene.new
+  end
+
+  def test_true
+    assert true
+  end
+
+  def test_polygon_has_extra_methods
+    assert @gene.polygon.respond_to?(:num_points)
+    assert @gene.polygon.respond_to?(:points)
+  end
+  
+  def test_polygon_has_correct_setup
+    @gene.polygon.points.each do |point|
+      assert point.class   == Point
+      assert point.x.class == Trait
+      assert point.y.class == Trait
+    end
+  end
+  
+  def test_color_has_correct_setup
+    [:r, :g, :b, :a].each do |channel|
+      assert_equal Trait, @gene.color.send(channel).class
+    end
+  end
+  
+  def test_initialize__no_default_values
+    image_dimensions = Point.new(640, 480)
+    
+    assert_equal 3, @gene.polygon.num_points
+    
+    @gene.polygon.points.each do |point|
+      assert((0...image_dimensions.x) === point.x.value)
+      assert((0...image_dimensions.y) === point.y.value)
+    end
+ 
+    @gene.color.rgb.each do |channel|
+      assert((0.0..1.0) === channel.value)
+    end
+  end
+  
+  def test_initialize__with_block
+    gene = Gene.new do
+      point_1_x { set_value 100 }
+      
+      point_2 100, 100
+      
+      trait_r { set_value 100 }
+    end
+    
+    lambda do |index|
+      assert gene.polygon[index].x.is_a?(Trait)
+      assert gene.polygon[index].y.is_a?(Trait)
+    end | Petri.num_points.times
+    
+    lambda do |trait_name|
+      assert gene.color.send(trait_name).is_a?(Trait)
+    end | %w[r g b a]
+    
+    assert_equal 100, gene.polygon[1].x.value
+    assert_equal 100, gene.polygon[2].x.value
+    assert_equal 100, gene.polygon[2].y.value
+    assert_equal 100, gene.color.r.value
+    
+    assert_raise NoMethodError do
+      Gene.new(3, Point.new(640, 480)) { rawr! }
+    end
+  end
+end

data/test/unit/generator_test.rb

@@ -0,0 +1,76 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper.rb")
+
+class GeneratorTest < Test::Unit::TestCase
+  def setup
+    Petri.stubs(:image_dimensions).returns(Point.new(640, 480))
+    Petri.stubs(:num_genes).returns(5)
+    Petri.stubs(:num_points).returns(3)
+    
+    @cell_1 = Cell.new
+    @cell_2 = Cell.new
+    [@cell_1, @cell_2].each { |cell| cell.fitness = 0.5 }
+    
+    @generator = Generator.new(@cell_1, @cell_2)
+  end
+  
+  def test_true
+    assert true
+  end
+  
+  def test_initialize__with_block
+    assert_equal Generator::DEFAULT_XOVER_FREQ,    @generator.xover_freq
+    assert_equal Generator::DEFAULT_MUTATION_FREQ, @generator.mutation_freq
+    
+    generator = Generator.new(@cell_1, @cell_2) do
+      set_xover_freq    1.0
+      set_mutation_freq 1.0
+    end
+    
+    assert_equal 1.0, generator.xover_freq
+    assert_equal 1.0, generator.mutation_freq
+    
+    assert_raise NoMethodError do
+      Generator.new(@cell_1, @cell_2) do
+        rawr!
+      end
+    end
+  end
+  
+  def test_combine
+    assert_equal Cell, @generator.combine.class
+  end
+  
+  def test_mutate__returns_normal_trait_value
+    @generator.instance_variable_set(:@mutation_freq, 0)
+    
+    trait = mock
+    trait.expects(:value)
+  
+    @generator.send(:mutate, trait)
+  end
+    
+  def test_mutate__returns_mutated_trait_value
+    @generator.instance_variable_set(:@mutation_freq, 1)
+    
+    trait = mock
+    trait.expects(:mutated_value)
+  
+    @generator.send(:mutate, trait)
+  end
+    
+  def test_read_sequence
+    @generator.instance_variable_set(:@current_sequence, 0)
+    @generator.instance_variable_set(:@xover_freq, 1)
+    
+    assert_equal 1, @generator.send(:read_sequence)
+    assert_equal 0, @generator.send(:read_sequence)
+    
+    @generator.instance_variable_set(:@xover_freq, 0)
+    
+    assert_equal 0, @generator.send(:read_sequence)
+    
+    @generator.instance_variable_set(:@current_sequence, 1)
+    
+    assert_equal 1, @generator.send(:read_sequence)
+  end
+end

data/test/unit/geometry_test.rb

@@ -0,0 +1,57 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper.rb")
+
+class GeometryTest < Test::Unit::TestCase
+  class TestClass
+    include Geometry
+
+    attr_accessor :polygon
+  end
+  
+  def setup
+    @test_class = TestClass.new
+  end
+  
+  def test_true
+    assert true
+  end
+  
+  def test_hull__less_than_three_points
+    point_lists = [[], [create_point(0, 0)], [create_point(0, 0), create_point(0, 0)]]
+    
+    point_lists.each do |point_list|
+      assert_raise ArgumentError do
+        @test_class.polygon = point_list
+        @test_class.hulled_sequence
+      end
+    end
+  end
+  
+  def test_hull_simple_case
+    @test_class.polygon = [create_point(0, 0), create_point(50, 0), create_point(50, 50)]
+    assert_equal [0, 0, 50, 50, 50, 0], @test_class.hulled_sequence
+  end
+  
+  def test_hull__one_point_inside
+    @test_class.polygon = [create_point(0, 0), create_point(50, 0), create_point(50, 50), create_point(10, 5)]
+    assert_equal [0, 0, 50, 50, 50, 0], @test_class.hulled_sequence
+  end
+  
+  def test_hull__three_points_on_a_line
+    @test_class.polygon = [create_point(0, 0), create_point(25, 0), create_point(50, 0), create_point(50, 50)]
+    assert_equal [0, 0, 50, 50, 50, 0], @test_class.hulled_sequence
+  end
+  
+  def test_hull__three_points_on_a_line_with_one_point_inside
+    @test_class.polygon = [create_point(0, 0), create_point(25, 0), create_point(50, 0), create_point(50, 50), create_point(10, 5)]
+    assert_equal [0, 0, 50, 50, 50, 0], @test_class.hulled_sequence
+  end
+  
+  protected
+  
+  def create_point(x, y)
+    Point.new(
+      Trait.new(0...100) { set_value x },
+      Trait.new(0...100) { set_value y }
+    )
+  end
+end

data/test/unit/hungarian_test.rb

@@ -0,0 +1,196 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper.rb")
+
+class TraitTest < Test::Unit::TestCase
+  def setup
+    @hungarian = Hungarian.new([[1, 0], [0, 1]])
+  end
+
+  def test_true
+    assert true
+  end
+
+  def test_minimize_rows
+    @hungarian.instance_variable_set(:@matrix, [[1, 2, 3], [1, 0, 1], [2, 2, 2]])
+    @hungarian.send(:minimize_rows)
+    assert_equal [[0, 1, 2], [1, 0, 1], [0, 0, 0]], @hungarian.instance_variable_get(:@matrix)
+  end
+  
+  def test_star_zeroes
+    @hungarian.instance_variable_set(:@matrix, [[0, 0], [0, 0]])
+    @hungarian.expects(:reset_covered_hash)
+    
+    assert_equal [[Hungarian::EMPTY, Hungarian::EMPTY], [Hungarian::EMPTY, Hungarian::EMPTY]], @hungarian.instance_variable_get(:@mask)
+    expected_hash = {:rows => [false, false], :columns => [false, false]}
+    assert_equal expected_hash, @hungarian.instance_variable_get(:@covered)
+    
+    @hungarian.send(:star_zeroes)
+    
+    assert_equal [[Hungarian::STAR, Hungarian::EMPTY], [Hungarian::EMPTY, Hungarian::STAR]], @hungarian.instance_variable_get(:@mask)
+    expected_hash = {:rows => [true, true], :columns => [true, true]}
+    assert_equal expected_hash, @hungarian.instance_variable_get(:@covered)
+  end
+  
+  def test_mask_columns__not_all_columns_covered
+    @hungarian.expects(:index_range).returns((0..1))
+    @hungarian.expects(:column_mask_values_for).twice.returns(stub(:any? => true), stub(:any? => false))
+    assert_equal :prime_zeroes, @hungarian.send(:mask_columns)
+  end
+
+  def test_mask_columns__all_columns_covered
+    @hungarian.expects(:index_range).returns((0..1))
+    @hungarian.expects(:column_mask_values_for).twice.returns(stub(:any? => true))
+    assert_equal :finished, @hungarian.send(:mask_columns)
+  end
+
+  def test_prime_zeroes__breaks_when_no_uncovered_zeroes
+    @hungarian.expects(:find_uncovered_zero).returns([-1, -1])
+    assert_equal :adjust_matrix, @hungarian.send(:prime_zeroes)
+  end
+  
+  def test_prime_zeroes__star_in_row
+    @hungarian.instance_variable_set(:@covered, {:rows => [nil, nil], :columns => [nil, nil]})
+    
+    @hungarian.expects(:find_uncovered_zero).twice.returns([0, 0], [-1, -1])
+    @hungarian.expects(:row_mask_values_for).with(0).returns(stub(:index => 0))
+    assert_equal :adjust_matrix, @hungarian.send(:prime_zeroes)
+    
+    expected_hash = {:rows => [true, nil], :columns => [false, nil]}
+    assert_equal expected_hash, @hungarian.instance_variable_get(:@covered)
+  end
+  
+  def test_prime_zeroes__star_not_in_row
+    @hungarian.instance_variable_set(:@covered, {:rows => [nil, nil], :columns => [nil, nil]})
+    
+    @hungarian.expects(:find_uncovered_zero).returns([0, 0])
+    @hungarian.expects(:row_mask_values_for).with(0).returns(stub(:index => nil))
+    assert_equal [:augment_path, 0, 0], @hungarian.send(:prime_zeroes)
+    
+    expected_hash = {:rows => [nil, nil], :columns => [nil, nil]}
+    assert_equal expected_hash, @hungarian.instance_variable_get(:@covered)
+  end
+  
+  def test_augment_path__break_out_on_first_loop
+    path = [0, 0]
+    @hungarian.expects(:column_mask_values_for).with(path[1]).returns(stub(:index => nil))
+    
+    @hungarian.expects(:update_elements_in).with([path])
+    @hungarian.expects(:traverse_indices)
+    @hungarian.expects(:reset_covered_hash)
+    
+    assert_equal :mask_columns, @hungarian.send(:augment_path, *path)
+  end
+  
+  def test_augment_path__loop_once_then_break    
+    path = [0, 0]
+    @hungarian.expects(:column_mask_values_for).twice.with(anything).returns(stub(:index => 1), stub(:index => nil))
+    @hungarian.expects(:row_mask_values_for).with(anything).returns(stub(:index => 1))
+    
+    @hungarian.expects(:update_elements_in).with([path, [1, 0], [1, 1]])
+    @hungarian.expects(:traverse_indices)
+    @hungarian.expects(:reset_covered_hash)
+    
+    assert_equal :mask_columns, @hungarian.send(:augment_path, *path)
+  end
+  
+  def test_adjust_matrix
+    @hungarian.instance_variable_set(:@matrix, [[1, 2], [3, 4]])
+    @hungarian.instance_variable_set(:@covered, {:rows => [false, true], :columns => [false, true]})
+    
+    expected_matrix = [[0, 2], [3, 5]]
+    assert_equal :prime_zeroes, @hungarian.send(:adjust_matrix)
+    assert_equal expected_matrix, @hungarian.instance_variable_get(:@matrix)
+  end
+
+  def test_assignment
+    @hungarian.instance_variable_set(:@mask, [[Hungarian::STAR, Hungarian::EMPTY], [Hungarian::EMPTY, Hungarian::STAR]])
+    assert_equal [[0, 0], [1, 1]], @hungarian.send(:assignment)
+    
+    @hungarian.instance_variable_set(:@mask, [[Hungarian::EMPTY, Hungarian::STAR], [Hungarian::STAR, Hungarian::EMPTY]])
+    assert_equal [[0, 1], [1, 0]], @hungarian.send(:assignment)
+  end
+
+  def test_update_elements_in_path
+    @hungarian.instance_variable_set(:@mask, [[Hungarian::STAR, Hungarian::EMPTY], [Hungarian::EMPTY, Hungarian::PRIME]])
+    @hungarian.send(:update_elements_in, [[0, 0], [1, 1]])
+    assert_equal [[Hungarian::EMPTY, Hungarian::EMPTY], [Hungarian::EMPTY, Hungarian::STAR]], @hungarian.instance_variable_get(:@mask)
+  end
+
+  def test_find_uncovered_zero
+    hungarian = Hungarian.new([[0, 0], [0, 0]])
+    hungarian.instance_variable_set(:@covered, {:rows => [false, true], :columns => [false, true]})
+    assert_equal [0, 0], hungarian.send(:find_uncovered_zero)
+    
+    hungarian = Hungarian.new([[0, 0], [0, 0]])
+    hungarian.instance_variable_set(:@covered, {:rows => [true, false], :columns => [true, false]})
+    assert_equal [1, 1], hungarian.send(:find_uncovered_zero)
+  end
+  
+  def test_find_uncovered_zero__cell_skipped_if_value_nonzero__default_returned
+    hungarian = Hungarian.new([[1, 1], [1, 1]])
+    assert_equal [-1, -1], hungarian.send(:find_uncovered_zero)    
+  end
+  
+  def test_cover_cell
+    @hungarian.instance_variable_set(:@covered, {:rows => [false, false], :columns => [false, false]})
+    @hungarian.send(:cover_cell, 0, 0)
+    
+    expected_hash = {:rows => [true, false], :columns => [true, false]}
+    assert_equal expected_hash, @hungarian.instance_variable_get(:@covered)
+  end
+  
+  def test_reset_covered_hash
+    @hungarian.instance_variable_set(:@covered, {:rows => [true, false], :columns => [true, false]})
+    @hungarian.send(:reset_covered_hash)
+    
+    expected_hash = {:rows => [false, false], :columns => [false, false]}
+    assert_equal expected_hash, @hungarian.instance_variable_get(:@covered)
+  end
+  
+  def test_location_covered
+    @hungarian.instance_variable_set(:@covered, {:rows => [false], :columns => [false]})
+    assert_equal false, @hungarian.send(:location_covered?, 0, 0)
+    
+    @hungarian.instance_variable_set(:@covered, {:rows => [true], :columns => [false]})
+    assert_equal true, @hungarian.send(:location_covered?, 0, 0)
+    
+    @hungarian.instance_variable_set(:@covered, {:rows => [false], :columns => [true]})
+    assert_equal true, @hungarian.send(:location_covered?, 0, 0)
+    
+    @hungarian.instance_variable_set(:@covered, {:rows => [true], :columns => [true]})
+    assert_equal true, @hungarian.send(:location_covered?, 0, 0)
+  end
+  
+  def test_row_mask_values_for
+    @hungarian.instance_variable_set(:@mask, [[0, 1], [2, 3]])
+    assert_equal [0, 1], @hungarian.send(:row_mask_values_for, 0)
+    assert_equal [2, 3], @hungarian.send(:row_mask_values_for, 1)
+  end
+    
+  def test_column_mask_values_for
+    @hungarian.instance_variable_set(:@mask, [[0, 1], [2, 3]])
+    assert_equal [0, 2], @hungarian.send(:column_mask_values_for, 0)
+    assert_equal [1, 3], @hungarian.send(:column_mask_values_for, 1)
+  end
+ 
+  def test_indices_of_covered_rows
+    @hungarian.instance_variable_set(:@length, 3)
+    @hungarian.instance_variable_set(:@covered, {:rows => [true, false, true], :columns => [true, false, true]})
+    assert_equal [0, 2], @hungarian.send(:indices_of_covered_rows)
+  end
+  
+  def test_indices_of_uncovered_columns
+    @hungarian.instance_variable_set(:@length, 3)
+    @hungarian.instance_variable_set(:@covered, {:rows => [false, true, false], :columns => [false, true, false]})
+    assert_equal [0, 2], @hungarian.send(:indices_of_uncovered_columns)
+  end
+  
+  def test_traverse_indices
+    traversal = []
+    @hungarian.send(:traverse_indices) { |row, column| traversal << [row, column] }
+    assert_equal [[0, 0], [0, 1], [1, 0], [1, 1]], traversal
+  end
+  
+  def test_index_range
+    assert_equal 0...2, @hungarian.send(:index_range)
+  end
+end

data/test/unit/imagine_test.rb

@@ -0,0 +1,54 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper.rb")
+
+class ImagineTest < Test::Unit::TestCase
+  RGB = Struct.new(:red, :green, :blue)
+  
+  class TestClass
+    include Imagine
+
+    def image_dimensions
+      Point.new(2, 2)
+    end
+
+    def each_pixel
+      [
+        [RGB.new(0, 0, 0), 0, 0],
+        [RGB.new(0, 0, 0), 0, 1],
+        [RGB.new(0, 0, 0), 1, 0],
+        [RGB.new(0, 0, 0), 1, 1]
+      ].each { |params| yield *params }
+    end
+  end
+  
+  def setup
+    Magick.send(:remove_const, :MaxRGB)
+    Magick.const_set(:MaxRGB, 1)
+    
+    @test_class = TestClass.new
+    @test_class.stubs(:target_image).returns(@test_class)
+  end
+  
+  def test_true
+    assert true
+  end
+  
+  def test_compare_image_to__identical_returns_1
+    assert_in_delta 1.0, @test_class.compare_image_to(image_of_color(RGB.new(0, 0, 0))), 1e-5
+  end
+  
+  def test_compare_image_to__opposite_returns_0
+    assert_in_delta 0.0, @test_class.compare_image_to(image_of_color(RGB.new(1, 1, 1))), 1e-5
+  end
+  
+  def test_compare_image_to__50_percent
+    assert_in_delta 0.5, @test_class.compare_image_to(image_of_color(RGB.new(0.5, 0.5, 0.5))), 1e-5
+  end
+  
+  private
+  
+  def image_of_color(color)
+    returning(stub) do |image|
+      2.times { |x| 2.times { |y| image.stubs(:pixel_color).with(x, y).returns(color) } }
+    end
+  end
+end