gene 0.0.1 → 0.1.0

data/lib/point.rb

@@ -0,0 +1 @@
+Point = Struct.new(:x, :y)

data/lib/trait.rb

@@ -0,0 +1,60 @@
+class Trait < Dsl
+  include Calculator
+  
+  STANDARD_DEVIATION = {
+    :default => 0.1,
+    :range   => 0.01..0.25
+  }
+  
+  attr_reader :value, :range, :standard_deviation
+  
+  def initialize(range)
+    @range = range
+    super
+  end
+  
+  def mutated_value
+    new_value = value + standard_deviation * Trait.get_normal_random_variable
+    new_value = new_value.round if value.is_a?(Fixnum)
+    
+    if new_value > range.max
+      range.max
+    elsif new_value < range.min
+      range.min
+    else
+      new_value
+    end
+  end
+  
+  def percentify
+    "#{value / range.max.to_f * 100}%"
+  end
+  
+  private
+  
+  def finish_init
+    fill_out_value
+    fill_out_deviation
+  end
+  
+  def fill_out_value    
+    @value ||= Trait.generate_value(range.max)
+  end
+  
+  def fill_out_deviation
+    @standard_deviation ||= STANDARD_DEVIATION[:default] * range.max
+  end
+  
+  def new_standard_deviation_from(fitness)
+    deviation_range = STANDARD_DEVIATION[:range].max - STANDARD_DEVIATION[:range].min
+    STANDARD_DEVIATION[:range].max - deviation_range * fitness
+  end
+  
+  def method_missing(name, *args, &block)
+    case name.to_s
+    when /^set_value$/:    @value              = args.first
+    when /^deviation$/:    @standard_deviation = args.first * range.max
+    when /^deviate_from$/: @standard_deviation = new_standard_deviation_from(args.first)
+    else super end
+  end
+end

data/tasks/test.rake

@@ -0,0 +1,23 @@
+desc "Runs the test suite"
+task :test do  
+  require "benchmark"
+  
+  totals = { :tests => 0, :assertions => 0, :failures => 0, :errors => 0 }
+  Benchmark.measure do
+
+    FileList["./test/**/*_test.rb"].map { |path| path.gsub("test/", "") }.each do |test|
+      results = `ruby -C test/ #{test}`
+      results =~ /(\d+) tests, (\d+) assertions, (\d+) failures, (\d+) errors/
+  
+      totals[:tests]      += $1.to_i
+      totals[:assertions] += $2.to_i
+      totals[:failures]   += $3.to_i
+      totals[:errors]     += $4.to_i 
+  
+      print "#{results}\n"
+    end
+  end.real.to_s.match(/(\d+\.\d{2})/)
+
+  print "Total results: #{totals[:tests]} tests run in #{$1} seconds: #{totals[:assertions]} assertions, #{totals[:failures]} failures, #{totals[:errors]} errors\n\n"
+  print "Your tests are #{totals[:failures].zero? && totals[:errors].zero? ? 'PASSING' : 'FAILING'}.\n"
+end

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+require "rubygems"
+require "mocha"
+require "test/unit"
+
+# Pulls in the runner.rb file to autoload dependencies.
+require File.join(File.dirname(__FILE__), "..", "initializers", "runner.rb")

data/test/unit/aligner_test.rb

@@ -0,0 +1,91 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper.rb")
+
+class AlignerTest < Test::Unit::TestCase
+  class TestClass
+    attr_accessor :cells
+
+    include Aligner
+  end
+  
+  def setup
+    Petri.stubs(:image_dimensions).returns(Point.new(640, 480))
+    Petri.stubs(:num_genes).returns(3)
+    Petri.stubs(:num_points).returns(3)
+    
+    @test_class = TestClass.new
+  end
+  
+  def test_true
+    assert true
+  end
+
+  def test_align_crossover_for
+    @test_class.cells = [
+      Cell.new do
+        gene_0 &three_points_at(0, 0)
+        gene_1 &three_points_at(10, 0)
+        gene_2 &three_points_at(20, 0)
+      end,
+      Cell.new do
+        gene_0 &three_points_at(10, 0)
+        gene_1 &three_points_at(20, 0)
+        gene_2 &three_points_at(30, 0)
+      end
+    ]
+
+    optimal_alignment = @test_class.align_crossover
+    
+    assert_equal [0, 1, 2], optimal_alignment[:cell_1]
+    assert_equal [1, 0, 2], optimal_alignment[:cell_2]
+  end
+  
+  def test_crossover_map
+    Petri.stubs(:num_genes).returns(2)
+    
+    @test_class.cells = [
+      Cell.new do
+        gene_0 &three_points_at(0, 0)
+        gene_1 &three_points_at(15, 0)
+      end,
+      Cell.new do
+        gene_0 &three_points_at(10, 0)
+        gene_1 &three_points_at(22.5, 0)
+      end
+    ]
+
+    assert_equal [[10, 22.5], [5, 7.5]], @test_class.send(:crossover_map)
+  end
+  
+  def test_middle_point_of
+    Petri.stubs(:num_points).returns(4)
+    
+    gene = Gene.new do
+      point_0 0, 0
+      point_1 30, 0
+      point_2 0, 15
+      point_3 30, 15
+    end
+    
+    middle_point = @test_class.send(:middle_point_of, gene)
+    
+    assert_equal 15, middle_point.x
+    assert_equal 7.5, middle_point.y
+  end
+  
+  def test_distance_between
+    point_1 = Point.new(0, 0)
+    point_2 = Point.new(3, 4)
+    
+    assert_equal 5, @test_class.send(:distance_between, point_1, point_2)
+  end
+  
+  protected
+  
+  def three_points_at(x, y)
+    lambda do
+      point_0 x, y
+      point_1 x, y
+      point_2 x, y
+    end
+  end
+end

data/test/unit/calculator_test.rb

@@ -0,0 +1,100 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper.rb")
+
+class CalculatorTest < Test::Unit::TestCase
+  class TestClass
+    include Calculator
+  end
+  
+  def test_true
+    assert true
+  end
+  
+  def test_generate_value__raises_error_when_max_is_nil_or_zero
+    assert_raise ArgumentError do 
+      TestClass.generate_value(nil) 
+    end
+    
+    assert_raise ArgumentError do 
+      TestClass.generate_value(0) 
+    end
+  end
+  
+  def test_generate_value__returns_same_type_as_max    
+    assert TestClass.generate_value(1.0).is_a?(Float)
+    assert TestClass.generate_value(100).is_a?(Fixnum)
+  end
+
+  def test_get_normal_random_variable__x
+    sum = mock
+    sum.expects(:+).with(:y).returns(sum)
+    sum.expects(:<).with(1).returns(true)
+    
+    x = mock
+    x.expects(:**).with(2).returns(sum)
+    y = mock
+    y.expects(:**).with(2).returns(:y)
+    
+    TestClass.expects(:get_uniform_random_variable).twice.returns(x, y)
+    TestClass.expects(:rand).with(2).returns(0)
+    TestClass.expects(:convert).with(x, sum)
+    
+    TestClass.get_normal_random_variable
+  end
+
+  def test_get_normal_random_variable__y
+    sum = mock
+    sum.expects(:+).with(:y).returns(sum)
+    sum.expects(:<).with(1).returns(true)
+    
+    x = mock
+    x.expects(:**).with(2).returns(sum)
+    y = mock
+    y.expects(:**).with(2).returns(:y)
+    
+    TestClass.expects(:get_uniform_random_variable).twice.returns(x, y)
+    TestClass.expects(:rand).with(2).returns(1)
+    TestClass.expects(:convert).with(y, sum)
+    
+    TestClass.get_normal_random_variable
+  end
+
+  def test_get_normal_random_variable__loops_until_sum_is_less_than_one
+    sum = mock
+    sum.expects(:+).with(:y).returns(sum)
+    sum.expects(:<).with(1).returns(true)
+    
+    x = mock
+    x.expects(:**).with(2).returns(sum)
+    y = mock
+    y.expects(:**).with(2).returns(:y)
+    
+    TestClass.expects(:get_uniform_random_variable).times(4).returns(1, 1, x, y)
+    TestClass.expects(:rand).with(2).returns(0)
+    TestClass.expects(:convert).with(x, sum)
+    
+    TestClass.get_normal_random_variable
+  end
+
+  def test_get_uniform_random_variable
+    random_value = mock
+    random_value.expects(:*).with(:sign)
+    TestClass.expects(:rand).with(0).returns(random_value)
+    TestClass.expects(:random_sign_change).returns(:sign)
+    
+    TestClass.get_uniform_random_variable
+  end
+  
+  def test_random_sign_change
+    TestClass.expects(:rand).with(2).returns(0)
+    assert_equal 1, TestClass.send(:random_sign_change)
+    
+    TestClass.expects(:rand).with(2).returns(1)
+    assert_equal -1, TestClass.send(:random_sign_change)
+  end
+  
+  def test_convert
+    assert_equal 0, TestClass.send(:convert, 1, 0)
+    assert_equal 0, TestClass.send(:convert, 0, 0)
+    assert_equal 0, TestClass.send(:convert, 0, 1)
+  end
+end

data/test/unit/cell_test.rb

@@ -0,0 +1,64 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper.rb")
+
+class CellTest < Test::Unit::TestCase
+  def setup
+    Petri.stubs(:image_dimensions).returns(Point.new(640, 480))
+    Petri.stubs(:num_genes).returns(3)
+    Petri.stubs(:num_points).returns(3)
+    
+    @cell = Cell.new
+  end
+  
+  def test_true
+    assert true
+  end
+
+  def test_initialize
+    image_range_x = 0...Petri.image_dimensions.x
+    image_range_y = 0...Petri.image_dimensions.y
+    channel_range = 0.0..1.0
+
+    @cell.genes.each do |gene|      
+      assert_equal Petri.num_points, gene.polygon.num_points
+      
+      assert gene.polygon.points.all? { |point| image_range_x.include?(point.x.value) && image_range_y.include?(point.y.value) }
+      assert gene.color.each_pair { |channel, trait| channel_range.include?(trait.value) }
+    end
+  end
+  
+  def test_initialize__with_block
+    lambda { |index| assert Cell.new.genes[index].is_a?(Gene) } | Petri.num_genes.times
+    
+    assert_raise NoMethodError do
+      Cell.new { rawr! }
+    end
+  end
+  
+  def test_genes_by_alpha
+    cell = Cell.new do
+      gene_0 do
+        trait_a do
+          set_value 0.5
+        end
+      end
+      gene_1 do
+        trait_a do
+          set_value 0.0
+        end
+      end
+      gene_2 do
+        trait_a do
+          set_value 1.0
+        end
+      end
+    end
+    
+    assert_equal [0.5, 0.0, 1.0], cell.genes.map(&:color).map(&:a).map(&:value)    
+    assert_equal [1.0, 0.5, 0.0], cell.genes_by_alpha.map(&:color).map(&:a).map(&:value)
+  end
+  
+  def test_genes_from_alignment_map
+    cell = Cell.new
+    assert_equal [cell.genes[2], cell.genes[0], cell.genes[1]], cell.genes_from_alignment_map([2, 0, 1])
+  end
+end

data/test/unit/color_test.rb

@@ -0,0 +1,23 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper.rb")
+
+class ColorTest < Test::Unit::TestCase
+  def test_true
+    assert true
+  end
+  
+  def test_rgb
+    color = Color.new(:r, :g, :b, :a)
+    assert_equal [:r, :g, :b], color.rgb
+  end
+  
+  def test_rgba_format
+    color = Color.new(
+      Trait.new(0.0..1.0) { set_value 0 },
+      Trait.new(0.0..1.0) { set_value 0.25 },
+      Trait.new(0.0..1.0) { set_value 0.5 },
+      Trait.new(0.0..1.0) { set_value 0.75 }
+    )
+    
+    assert_equal "rgba(0.0%, 25.0%, 50.0%, 0.75)", color.rgba_format
+  end
+end

data/test/unit/dsl_test.rb

@@ -0,0 +1,45 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper.rb")
+
+class DslTest < Test::Unit::TestCase
+  class TestClass < Dsl
+    def initialize
+      @set_in_init = true
+      super
+    end
+
+    def finish_init
+      @set_in_finish_init = true
+    end
+  end
+  
+  def setup
+    @test_class = TestClass.new do
+      @set_in_block = true
+      method_in_binding_scope
+    end
+  end
+  
+  def test_true
+    assert true
+  end
+  
+  def test_dsl__self_changed_in_block
+    %w[init finish_init block].each do |suffix|
+      assert @test_class.instance_variable_get(:"@set_in_#{suffix}")
+    end
+    
+    assert_raise NoMethodError do
+      TestClass.new { rawr! }
+    end
+  end
+  
+  def test_dsl__method_resolution_in_binding_scope
+    assert @set_in_binding_scope
+  end
+  
+  private
+  
+  def method_in_binding_scope
+    @set_in_binding_scope = true
+  end
+end

data/test/unit/functionals_extensions_test.rb

@@ -0,0 +1,51 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper.rb")
+
+class FunctionalExtensionsTest < Test::Unit::TestCase  
+  def test_true
+    assert true
+  end
+  
+  def test_apply
+    sum = lambda { |x, y| x + y }
+    
+    assert_equal [3, 7], sum | [[1, 2], [3, 4]]
+    assert_equal [3, 7], sum.apply([[1, 2], [3, 4]])
+  end
+
+  def test_reduce
+    sum = lambda { |x, y| x + y }
+    
+    assert_equal 10, sum <= [1, 2, 3, 4]
+    assert_equal 10, sum.reduce([1, 2, 3, 4])
+  end
+  
+  def test_compose
+    add_1  = lambda { |x| x + 1 }
+    double = lambda { |x| x * 2 }
+    
+    assert_equal 5, (add_1 * double)[2]
+    assert_equal 5, (add_1.compose(double))[2]
+    
+    assert_equal 6, (double * add_1)[2]
+    assert_equal 6, (double.compose(add_1))[2]
+  end
+  
+  
+  def test_apply_head
+    function = lambda { |x, y, z| x * y + z }
+    assert_equal 24, (function >> 5)[4, 4]
+  end
+  
+  def test_apply_tail
+    function = lambda { |x, y, z| x * y + z }
+    assert_equal 21, (function << 5)[4, 4]
+  end
+  
+  def test_memoize
+    factorial = +lambda { |x| x == 1 ? 1 : x * factorial[x - 1] }
+    assert_equal 120, factorial[5]
+    
+    factorial = lambda { |x| x == 1 ? 1 : x * factorial[x - 1] }.memoize
+    assert_equal 120, factorial[5]
+  end
+end