feldtruby 0.3.8 → 0.3.9

data/test/test_optimize_objective.rb

@@ -1,28 +1,56 @@
+require 'feldtruby/minitest_extensions'
+
 require 'feldtruby/optimize/objective'
 require 'feldtruby/array'
-
 require 'pp'
 
 class SingleObjective1 < FeldtRuby::Optimize::Objective
-	# Sum of candidate vector of values should be small
-	def objective_min_small_sum(candidate)
+	# Sum of candidate vector of values should be as small as possible
+	def objective_min_sum(candidate)
 		candidate.sum
 	end
 end
 
-class TestSingleObjective < MiniTest::Unit::TestCase
-	def setup
+describe "a single minimizing objective" do
+	before do
 		@o = SingleObjective1.new
 	end
 
-	def test_has_one_aspect
-		assert_equal 1, @o.num_aspects
+	it "has one aspect/sub-objective" do
+		@o.num_aspects.must_equal 1
+		@o.num_sub_objectives.must_equal 1
+	end
+
+	it "correctly calculates the sub-qualitites" do
+		@o.sub_qualities_of([1]).must_equal [1]
+		@o.sub_qualities_of([1, 2]).must_equal [3]
+		@o.sub_qualities_of([1, 2, -45]).must_equal [-42]
 	end
 
-	def test_quality_value
-		assert_equal 1, 	@o.quality_value([1])
-		assert_equal 3, 	@o.quality_value([1, 2])
-		assert_equal( -42, 	@o.quality_value([1, 2, -45]) )
+	it "correctly calculates the quality value / fitness_for" do
+		@o.quality_of([1]).must_equal 1
+		@o.quality_of([1, 2]).must_equal 3
+		@o.quality_of([1, 2, -45]).must_equal -42
+
+		@o.fitness_for([1]).must_equal 1
+		@o.fitness_for([1, 2]).must_equal 3
+		@o.fitness_for([1, 2, -45]).must_equal -42
+	end
+
+	it "can detect valid and invalid aspect/sub_objective names" do
+		@o.is_aspect_method?("objective_min_anything").must_be_truthy
+		@o.is_aspect_method?("objective_max_anything").must_be_truthy
+		@o.is_aspect_method?("objective_min_very_complex_names_are_not_a_problem").must_be_truthy
+		@o.is_aspect_method?("min_anything").must_be_falsey
+		@o.is_aspect_method?("max_anything").must_be_falsey
+	end
+
+	it "can detect valid and invalid minimization aspect/sub_objective names" do
+		@o.is_min_aspect_method?("objective_min_anything").must_be_truthy
+		@o.is_min_aspect_method?("objective_min_very_complex_names_are_not_a_problem").must_be_truthy
+		@o.is_min_aspect_method?("objective_max_anything").must_be_falsey
+		@o.is_min_aspect_method?("min_anything").must_be_falsey
+		@o.is_min_aspect_method?("max_anything").must_be_falsey
 	end
 end
 
@@ -35,97 +63,109 @@ class TwoMinObjectives1 < FeldtRuby::Optimize::Objective
 	end
 end
 
-class TestTwoObjectives < MiniTest::Unit::TestCase
-	def setup
+describe "two sub-objectives" do
+	before do
 		@o = TwoMinObjectives1.new
 	end
-	def test_has_two_aspects
-		assert_equal 2, @o.num_aspects		
-	end
-	def test_global_min_values_per_aspect
-		assert_equal [Float::INFINITY, Float::INFINITY], @o.global_min_values_per_aspect
-	end
-	def test_global_max_values_per_aspect
-		assert_equal [-Float::INFINITY, -Float::INFINITY], @o.global_max_values_per_aspect
-	end
-	def test_update_global_mins_and_maxs
-		@o.update_global_mins_and_maxs([1,2])
-		assert_equal [1,2], @o.global_min_values_per_aspect
-		assert_equal [1,2], @o.global_max_values_per_aspect
-
-		@o.update_global_mins_and_maxs([1,3])
-		assert_equal [1,2], @o.global_min_values_per_aspect
-		assert_equal [1,3], @o.global_max_values_per_aspect
-
-		@o.update_global_mins_and_maxs([0,8])
-		assert_equal [0,2], @o.global_min_values_per_aspect
-		assert_equal [1,8], @o.global_max_values_per_aspect
-	end
-	def test_sub_objective_values
-		assert_equal [1,3], @o.sub_objective_values([1,2])
-		assert_equal [3,7], @o.sub_objective_values([1,2,4])
-		assert_equal [4,8], @o.sub_objective_values([1,2,5])
-	end
-	def test_qv_mwgr
-		@o.update_global_mins_and_maxs([0, 0])
-		@o.update_global_mins_and_maxs([1, 3])
-		assert_equal 0.0, @o.qv_mwgr([1,2])
-		assert_equal 1.0, @o.qv_mwgr([0,0])
-	end
-	def test_qv_mwgr_complex
-		# Set first values => fitness is always zero
-		assert_equal 0.0, @o.qv_mwgr([1,2,3])
-		# Now we come with a worse candidate => still zero
-		assert_equal 0.0, @o.qv_mwgr([1,2,5])
-		# But now the previous value is the best candidate we have seen so gets maximum quality value, 2 aspects * 1.0 per aspect
-		assert_equal 1.0, @o.qv_mwgr([1,2,3])
-		# The previous worst is still the worst
-		assert_equal 0.0, @o.qv_mwgr([1,2,5])
-		# And now some complex ones that are between the prev best and worst
-		assert_equal( ((4.0 - 3.0)/(4-2) + (8.0 - 7)/(8-6))/2, @o.qv_mwgr([1,2,4]) )
-		assert_equal( ((4.0 - 3.5)/(4-2) + (8.0 - 7.5)/(8-6))/2, @o.qv_mwgr([1,2,4.5]) )
-		# Now extend the global best with a new best
-		assert_equal 1.0, @o.qv_mwgr([1,2,2]) # new global min = [1, 5] and max the same at [4, 8]
-		# And the in between candidates now have new values based on the new mins
-		assert_equal( ((4.0 - 3.0)/(4-1) + (8.0 - 7)/(8-5))/2, @o.qv_mwgr([1,2,4]) )
-		assert_equal( ((4.0 - 3.5)/(4-1) + (8.0 - 7.5)/(8-5))/2, @o.qv_mwgr([1,2,4.5]) )
-	end
+
+  it "has two aspects/sub-objectives" do
+    @o.num_aspects.must_equal 2
+    @o.num_sub_objectives.must_equal 2
+  end
+
+  it "returns the global min value per aspect, which is initially at a max value since we might not now its range" do
+    @o.global_min_values_per_aspect.must_equal [Float::INFINITY, Float::INFINITY]
+  end
+
+  it "returns the global max value per aspect, which is initially at a min value since we might not now its range" do
+    @o.global_max_values_per_aspect.must_equal [-Float::INFINITY, -Float::INFINITY]
+  end
+
+  it "correctly updates the global min and maxs, given a sequence of updates" do
+    @o.update_global_mins_and_maxs([1,2])
+    @o.global_min_values_per_aspect.must_equal [1,2]
+    @o.global_max_values_per_aspect.must_equal [1,2]
+
+    @o.update_global_mins_and_maxs([1,3])
+    @o.global_min_values_per_aspect.must_equal [1,2]
+    @o.global_max_values_per_aspect.must_equal [1,3]
+
+    @o.update_global_mins_and_maxs([0,8])
+    @o.global_min_values_per_aspect.must_equal [0,2]
+    @o.global_max_values_per_aspect.must_equal [1,8]
+  end
+
+  it "can return the vector of sub_objective values for a candidate" do
+    @o.sub_qualities_of([1,2]).must_equal [1,3]
+    @o.sub_qualities_of([1,2,4]).must_equal [3,7]
+    @o.sub_qualities_of([1,2,5]).must_equal [4,8]
+  end
+
+  it "correctly calculates mean-weighted-global-ratios" do
+    # Lets first update so there is a spread between mins and maxs
+    @o.update_global_mins_and_maxs([0, 0])
+    @o.update_global_mins_and_maxs([1, 3])
+
+    # Now check at either extreme of the interval, the quality value is always in [0.0, 1.0]
+    @o.qv_mwgr([1,2]).must_equal 0.0
+    @o.qv_mwgr([0,0]).must_equal 1.0
+  end
+
+  it "always returns a fitness_for of zero for the first call" do
+    @o.fitness_for([1,2,3]).must_equal 0.0
+  end
+
+  it "handles a more complex series of consecutive calls" do
+    # Set first values => fitness_for is always zero
+    @o.fitness_for([1,2,3]).must_equal 0.0
+
+    # Now we come with a worse candidate => still zero
+    @o.fitness_for([1,2,5]).must_equal 0.0
+    
+    # But now the previous value is the best candidate we have seen so gets maximum quality value
+    @o.fitness_for([1,2,3]).must_equal 1.0
+
+    # The previous worst is still the worst
+    @o.fitness_for([1,2,5]).must_equal 0.0
+
+    # And now some complex ones that are between the prev best and worst
+    @o.fitness_for([1,2,4]).must_equal (((4.0 - 3.0)/(4-2) + (8.0 - 7)/(8-6))/2)
+    @o.fitness_for([1,2,4.5]).must_equal (((4.0 - 3.5)/(4-2) + (8.0 - 7.5)/(8-6))/2)
+
+    # Now extend the global best with a new best
+    @o.fitness_for([1,2,2]).must_equal 1.0 # new global min = [1, 5] and max the same at [4, 8]
+
+    # And the in between candidates now have new values based on the new mins
+    @o.fitness_for([1,2,4]).must_equal (((4.0 - 3.0)/(4-1) + (8.0 - 7)/(8-5))/2)
+    @o.fitness_for([1,2,4.5]).must_equal (((4.0 - 3.5)/(4-1) + (8.0 - 7.5)/(8-5))/2)
+  end
 end
 
-describe "Objective" do
+describe "the objective itself and its updates" do
 	before do
 		@o = SingleObjective1.new
 		@o2 = TwoMinObjectives1.new
 		@c = [1,2,3]
 	end
 
-	it "attaches quality value to an evaluated object" do
-		qv = @o.quality_value(@c)
-		@c._quality_value.must_equal qv
-		@c._objective.must_equal @o
+	it "repeatedly returns the same quality value for an object unless the objective itself has been changed" do
+		qv = @o.quality_of(@c)
+		qv.must_equal @o.quality_of(@c)
 	end
 
-	it "overwrites quality value if evaluated again with another objective" do
-		@o.quality_value(@c)
-		qv2 = @o2.quality_value(@c)
-		@c._quality_value.must_equal qv2
-		@c._objective.must_equal @o2
+	it "returns different quality values for different objectives" do
+		qv = @o.quality_of(@c)
+		qv2 = @o2.quality_of(@c)
+		qv.wont_equal qv2
 	end
 
 	it "is re-evaluated if the objective has changed since original evaluation" do
-		qv = @o2.quality_value(@c)
-		@o2.quality_value([1,2,3,4,5]) # Higher sum so max updated
-		qvnew = @c._quality_value
+		qv = @o2.quality_of(@c)
+		@o2.quality_of([1,2,3,4,5]) # Higher sum so max updated
+		qvnew = @o2.quality_of(@c)
 		qvnew.wont_equal qv
 	end
 
-	describe "objects that have not been evaluated" do
-		it "has not attached quality values" do
-			c = [1,2,3]
-			c._quality_value.must_equal nil
-		end
-	end
-
 	describe "version numbers" do
 		it "has version number 0 when no evaluation has taken place" do
 			@o.current_version.must_equal 0
@@ -133,25 +173,25 @@ describe "Objective" do
 		end
 
 		it "never changes the version number for a single objective since ratios are not used" do
-			@o.quality_value([1])
+			@o.quality_of([1])
 			@o.current_version.must_equal 0			
 		end
 
 		it "increases the version number each time a quality aspect of a candidate is more extreme than previously seen (when multi-objective)" do
-			@o2.quality_value([1])
+			@o2.quality_of([1])
 			@o2.current_version.must_equal 4 # Both min and max changed for two objectives => 2*2
-			@o2.quality_value([2])
+			@o2.quality_of([2])
 			@o2.current_version.must_equal 5 # New max values for sum objective => +1
-			@o2.quality_value([1,2])
+			@o2.quality_of([1,2])
 			@o2.current_version.must_equal 7 # New max values for both objectives => +2
-			@o2.quality_value([0])
+			@o2.quality_of([0])
 			@o2.current_version.must_equal 8 # New min value for sum objective => +1
-			@o2.quality_value([-1])
+			@o2.quality_of([-1])
 			@o2.current_version.must_equal 9 # New min value for sum objective => +1
-			@o2.quality_value([-2])
+			@o2.quality_of([-2])
 			@o2.current_version.must_equal 10 # New min value for sum objective => +1
-			@o2.quality_value([1,2,3])
+			@o2.quality_of([1,2,3])
 			@o2.current_version.must_equal 12 # New max for both objectives => +1
 		end
 	end
-end
+end

data/test/test_optimize_search_space.rb

@@ -50,6 +50,60 @@ describe "SearchSpace#bound" do
 	end
 end
 
+describe "LatinHypercubeSampler" do
+	before do
+		@sampler = FeldtRuby::Optimize::SearchSpace::LatinHypercubeSampler.new
+		@sp = FeldtRuby::Optimize::SearchSpace.new([0, 2], [1, 5], @sampler)
+	end
+
+	it "has been linked up to the search space" do
+		@sampler.search_space.must_equal @sp
+	end
+
+	it "can generate a set of two valid candidates from a search space and they are properly spread out" do
+		100.times do
+			set = @sampler.sample_candidates(2)
+			set.must_be_instance_of Array
+			set.length.must_equal 2
+			c1, c2 = set
+			if c1[0] < 0.5
+				c2[0].must_be :>=, 0.5
+				c1[0].must_be :>=, 0.0
+			else
+				c2[0].must_be :<, 0.5
+				c1[0].must_be :<, 1.0
+			end
+			if c1[1] < 3.5
+				c2[1].must_be :>=, 3.5
+				c1[1].must_be :>=, 2.0
+			else
+				c2[1].must_be :<, 3.5
+				c1[1].must_be :<, 5.0
+			end
+		end
+	end
+
+	it "can generate a single candidate that are within the search space" do
+		100.times do
+			c = @sampler.sample_candidate
+			c.must_be_instance_of Array
+			c.length.must_equal 2
+			c[0].must_be :>=, 0.0
+			c[0].must_be :<, 1.0
+			c[1].must_be :>=, 2.0
+			c[1].must_be :<, 5.0
+		end
+	end
+
+	it "does not return the same candidate twice even if generating a single candidate" do
+		100.times do
+			c1 = @sampler.sample_candidate
+			c2 = @sampler.sample_candidate
+			c1.wont_equal c2
+		end
+	end
+end
+
 class TestSearchSpace < MiniTest::Unit::TestCase
 	def setup
 		@s1 = FeldtRuby::Optimize::SearchSpace.new([-5], [5])	

data/test/test_sax.rb

@@ -39,10 +39,23 @@ describe 'Symbolic Adaptive approXimation - SAX' do
     proc {SAX.new(3, 1)}.must_raise ArgumentError
   end
 
-  it "maps some simple time series to symbols when directly mapping" do
+  it "maps some simple time series to symbols when directly mapping values" do
     sax = SAX.new(1, 4)
     sax.process([-1, 0, 1]).must_equal [1,3,4]
     sax.process([-1, -0.5, 0, 0.5, 1]).must_equal [1,2,3,3,4]
     sax.process([-1, -0.5, 0, 0.5, 1].reverse).must_equal [1,2,3,3,4].reverse
   end
+
+  it "maps some simple time series to symbols when window size is 2" do
+    sax = SAX.new(2, 4)
+    sax.process([-1, 0, 0, 1]).must_equal [2,3]
+    sax.process([-1, 0, 0, 1]).must_equal [2,3]
+    sax.process([-1, -1, -1, 0, 0, 1, 1, 1]).must_equal [1,2,3,4]
+  end
+
+  it "maps some simple time series to symbols when window size is 4" do
+    sax = SAX.new(4, 4)
+    sax.process([-1, 0, 0, 1]).must_equal [3]
+    sax.process([-1, -1, -1, 0, 0, 1, 1, 1]).must_equal [1,4]
+  end
 end

data/test/test_sub_qualitites_comparator.rb

@@ -0,0 +1,109 @@
+require 'feldtruby/optimize/sub_qualities_comparators'
+
+describe "EpsilonNonDominance with epsilon=0.0 i.e. normal non-dominance" do
+  before do
+    @c = FeldtRuby::Optimize::EpsilonNonDominance.new(1, 0.0)
+  end
+
+  it "correctly calculates dominance for single-objective examples" do
+    @c.compare_sub_qualitites([1], [1]).must_equal 0
+
+    @c.first_dominates?([1], [1]).must_equal false
+    @c.second_dominates?([1], [1]).must_equal false
+
+    @c.compare_sub_qualitites([1], [2]).must_equal -1
+    @c.compare_sub_qualitites([2], [1]).must_equal 1
+
+    @c.compare_sub_qualitites([-1], [1]).must_equal -1
+    @c.compare_sub_qualitites([1], [-1]).must_equal 1
+
+    @c.compare_sub_qualitites([-10], [0]).must_equal -1
+    @c.compare_sub_qualitites([0], [-10]).must_equal 1
+  end
+
+  it "correctly calculates dominance for two-objective examples" do
+    @c.compare_sub_qualitites([2, 1], [2, 1]).must_equal 0
+
+    @c.compare_sub_qualitites([1, 2], [1, 3]).must_equal -1
+    @c.compare_sub_qualitites([1, 3], [1, 2]).must_equal 1
+
+    @c.compare_sub_qualitites([2, -1], [3, -1]).must_equal -1
+    @c.compare_sub_qualitites([3, -1], [2, -1]).must_equal 1
+
+    @c.compare_sub_qualitites([1, 2], [2, 1]).must_equal 0
+  end
+
+  it "correctly calculates dominance for three-objective examples" do
+    @c.compare_sub_qualitites([1, 2, 4], [1, 2, 4]).must_equal 0
+
+    @c.compare_sub_qualitites([1, 2, 4], [1, 3, 4]).must_equal -1
+    @c.compare_sub_qualitites([1, 3, 4], [1, 2, 4]).must_equal 1
+
+    @c.compare_sub_qualitites([1, 2, 3], [1, 3, 4]).must_equal -1
+    @c.compare_sub_qualitites([1, 3, 4], [1, 2, 3]).must_equal 1
+  end
+
+  it "never shows dominance when comparing the same objects" do
+    100.times do
+      candidate = Array.new(1 + rand(20)).map {rand(1e3)}
+      @c.compare_sub_qualitites(candidate, candidate).must_equal 0
+    end
+  end
+
+  it "always shows dominance when comparing objects where left is better in a single sub-objective" do
+    100.times do
+      candidate1 = Array.new(1 + rand(20)).map {rand(1e3)}
+      candidate2 = candidate1.clone
+      candidate2[rand(candidate2.length)] += 1
+      @c.compare_sub_qualitites(candidate1, candidate2).must_equal -1
+    end
+  end
+
+  it "always shows dominance when comparing objects where right is better in a single sub-objective" do
+    100.times do
+      candidate1 = Array.new(1 + rand(20)).map {rand(1e3)}
+      candidate2 = candidate1.clone
+      candidate2[rand(candidate2.length)] -= 1
+      @c.compare_sub_qualitites(candidate1, candidate2).must_equal 1
+    end
+  end
+end
+
+describe "EpsilonNonDominance with epsilon=1.0" do
+  before do
+    @c = FeldtRuby::Optimize::EpsilonNonDominance.new(1, 1.0)
+  end
+
+  it "correctly calculates dominance for single-objective examples" do
+    @c.compare_sub_qualitites([1], [1]).must_equal 0
+
+    @c.compare_sub_qualitites([1], [2]).must_equal 0
+    @c.compare_sub_qualitites([2], [1]).must_equal 0
+
+    @c.compare_sub_qualitites([1], [2.01]).must_equal -1
+    @c.compare_sub_qualitites([2.01], [1]).must_equal 1
+
+    @c.compare_sub_qualitites([-1], [1]).must_equal -1
+    @c.compare_sub_qualitites([1], [-1]).must_equal 1
+
+    @c.compare_sub_qualitites([-10], [0]).must_equal -1
+    @c.compare_sub_qualitites([0], [-10]).must_equal 1
+  end
+
+  it "correctly calculates dominance for two-objective examples" do
+    @c.compare_sub_qualitites([2, 1], [2, 1]).must_equal 0
+
+    @c.compare_sub_qualitites([1, 2], [1, 3]).must_equal 0
+    @c.compare_sub_qualitites([1, 3], [1, 2]).must_equal 0
+
+    @c.compare_sub_qualitites([1, 1.9], [1, 3]).must_equal -1
+    @c.compare_sub_qualitites([1, 3.1], [1, 2]).must_equal 1
+
+    @c.compare_sub_qualitites([2, -1], [4, -1]).must_equal -1
+    @c.compare_sub_qualitites([4, -1], [2, -1]).must_equal 1
+
+    @c.compare_sub_qualitites([1, 2], [2, 1]).must_equal 0
+
+    @c.compare_sub_qualitites([1, 3], [2, 1]).must_equal 1
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: feldtruby
 version: !ruby/object:Gem::Version
-  version: 0.3.8
+  version: 0.3.9
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-20 00:00:00.000000000 Z
+date: 2013-03-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rinruby
@@ -77,7 +77,11 @@ files:
 - lib/feldtruby/optimize/random_search.rb
 - lib/feldtruby/optimize/search_space.rb
 - lib/feldtruby/optimize/stdout_logger.rb
+- lib/feldtruby/optimize/sub_qualities_comparators.rb
 - lib/feldtruby/statistics.rb
+- lib/feldtruby/statistics/array_archive.rb
+- lib/feldtruby/statistics/clustering.rb
+- lib/feldtruby/statistics/distance.rb
 - lib/feldtruby/statistics/distance/string_distance.rb
 - lib/feldtruby/statistics/euclidean_distance.rb
 - lib/feldtruby/statistics/fastmap.rb
@@ -89,10 +93,14 @@ files:
 - lib/feldtruby/version.rb
 - lib/feldtruby/visualization/circos.rb
 - lib/feldtruby/word_counter.rb
+- spikes/zlib_for_short_strings.rb
 - test/helper.rb
+- test/skip_test_array_archive.rb
 - test/test_array.rb
 - test/test_array_basic_stats.rb
 - test/test_array_count_by.rb
+- test/test_clustering.rb
+- test/test_euclidean_distance.rb
 - test/test_fastmap.rb
 - test/test_float.rb
 - test/test_html_doc_getter.rb
@@ -106,6 +114,7 @@ files:
 - test/test_sax.rb
 - test/test_statistics.rb
 - test/test_string_distance.rb
+- test/test_sub_qualitites_comparator.rb
 - test/test_time.rb
 - test/test_vector.rb
 - test/test_word_counter.rb
@@ -135,9 +144,12 @@ specification_version: 3
 summary: Robert Feldt's Common Ruby Code lib
 test_files:
 - test/helper.rb
+- test/skip_test_array_archive.rb
 - test/test_array.rb
 - test/test_array_basic_stats.rb
 - test/test_array_count_by.rb
+- test/test_clustering.rb
+- test/test_euclidean_distance.rb
 - test/test_fastmap.rb
 - test/test_float.rb
 - test/test_html_doc_getter.rb
@@ -151,6 +163,7 @@ test_files:
 - test/test_sax.rb
 - test/test_statistics.rb
 - test/test_string_distance.rb
+- test/test_sub_qualitites_comparator.rb
 - test/test_time.rb
 - test/test_vector.rb
 - test/test_word_counter.rb