feldtruby 0.2.0

data/test/test_optimize.rb

@@ -0,0 +1,55 @@
+require 'feldtruby/optimize'
+
+class TestOptimize < MiniTest::Unit::TestCase
+	def test_rosenbrock_optimization_as_in_README
+		xbest, ybest = FeldtRuby::Optimize.optimize(0, 2, {:verbose => false}) {|x, y|
+			(1 - x)**2 + 100*(y - x*x)**2
+		}
+		assert_in_delta 1.0, xbest
+		assert_in_delta 1.0, ybest
+	end
+
+	def in_vicinity?(x, y, delta = 0.01)
+		(x-y).abs < delta
+	end
+
+	def test_himmelsblau_minimization
+		# For details see: http://en.wikipedia.org/wiki/Himmelblau%27s_function
+		xbest, ybest = FeldtRuby::Optimize.minimize(-5, 5, {:maxNumSteps => 5000, :verbose => false}) {|x, y|
+			(x*x + y - 11)**2 + (x + y*y + - 7)**2
+		}
+
+		# There are 4 local minima:
+		#   f( 3.000000,  2.000000) = 0.0
+		#   f(-2.805118,  3.131312) = 0.0
+		#   f(-3.779310, -3.283186) = 0.0
+		#   f( 3.584428, -1.848126) = 0.0
+		# and it is unlikely that we are not in the vicinity of one of those after optimization.
+
+		if in_vicinity?(xbest, 3.000000)
+			assert_in_delta 3.000000, xbest, 0.1
+			assert_in_delta 2.000000, ybest, 0.1
+		elsif in_vicinity?(xbest, -2.805118)
+			assert_in_delta -2.805118, xbest, 0.1
+			assert_in_delta 3.131312, ybest, 0.1
+		elsif in_vicinity?(xbest, -3.779310)
+			assert_in_delta -3.779310, xbest, 0.1
+			assert_in_delta -3.283186, ybest, 0.1
+		elsif in_vicinity?(xbest, 3.584428)
+			assert_in_delta 3.584428, xbest, 0.1
+			assert_in_delta -1.848126, ybest, 0.1
+		else
+			assert false, "Solution [#{xbest}, #{ybest}] is not close to any minima"
+		end
+	end
+
+	def test_himmelsblau_maximization
+		# There is a local maxima that can be found if we search in a smaller box around 0.0.
+		# For details see: http://en.wikipedia.org/wiki/Himmelblau%27s_function
+		xbest, ybest = FeldtRuby::Optimize.maximize(-1, 1, {:maxNumSteps => 2000, :verbose => false}) {|x, y|
+			(x*x + y - 11)**2 + (x + y*y + - 7)**2
+		}
+		assert_in_delta -0.270845, xbest, 0.1
+		assert_in_delta -0.923039, ybest, 0.1
+	end
+end

data/test/test_optimize_differential_evolution.rb

@@ -0,0 +1,42 @@
+require 'feldtruby/optimize/differential_evolution'
+require 'feldtruby/array/basic_stats'
+
+class MinimizeRMS < FeldtRuby::Optimize::Objective
+	def objective_min_rms(candidate)
+		candidate.rms
+	end
+end
+
+class MinimizeRMSAndSum < MinimizeRMS
+	def objective_min_sum(candidate)
+		candidate.sum.abs
+	end
+end
+
+class TestDifferentialEvolution < MiniTest::Unit::TestCase
+	include FeldtRuby::Optimize
+	def setup
+		@s2 = SearchSpace.new_symmetric(2, 1)
+		@s4 = SearchSpace.new_symmetric(4, 1)
+
+		@o1 = MinimizeRMS.new
+		@o2 = MinimizeRMSAndSum.new
+
+		@de1 = DEOptimizer.new(@o1, @s2, {:verbose => false, :maxNumSteps => 1000})
+		@de2 = DEOptimizer.new(@o2, @s4, {:verbose => false, :maxNumSteps => 1234})
+	end
+
+	def test_de_for_small_vector_with_rms
+		@de1.optimize()
+		# Very unlikely we get a number over 0.30 (2 elements) after 1000 steps...
+		assert @de1.best.sum <= 0.40
+		assert_equal 1000, @de1.num_optimization_steps
+	end
+
+	def test_de_for_small_vector_with_rms_and_sum_for_more_steps
+		@de2.optimize()
+		# Very unlikely we get a number over 0.40 (4 elements)...
+		assert @de2.best.sum <= 0.40
+		assert_equal 1234, @de2.num_optimization_steps
+	end
+end

data/test/test_optimize_objective.rb

@@ -0,0 +1,157 @@
+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)
+		candidate.sum
+	end
+end
+
+class TestSingleObjective < MiniTest::Unit::TestCase
+	def setup
+		@o = SingleObjective1.new
+	end
+
+	def test_has_one_aspect
+		assert_equal 1, @o.num_aspects
+	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]) )
+	end
+end
+
+class TwoMinObjectives1 < FeldtRuby::Optimize::Objective
+	def objective_min_distance_between(candidate)
+		candidate.distance_between_elements.sum
+	end
+	def objective_min_sum(candidate)
+		candidate.sum
+	end
+end
+
+class TestTwoObjectives < MiniTest::Unit::TestCase
+	def setup
+		@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
+end
+
+describe "Objective" 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
+	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
+	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
+		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
+			@o2.current_version.must_equal 0
+		end
+
+		it "never changes the version number for a single objective since ratios are not used" do
+			@o.quality_value([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.current_version.must_equal 4 # Both min and max changed for two objectives => 2*2
+			@o2.quality_value([2])
+			@o2.current_version.must_equal 5 # New max values for sum objective => +1
+			@o2.quality_value([1,2])
+			@o2.current_version.must_equal 7 # New max values for both objectives => +2
+			@o2.quality_value([0])
+			@o2.current_version.must_equal 8 # New min value for sum objective => +1
+			@o2.quality_value([-1])
+			@o2.current_version.must_equal 9 # New min value for sum objective => +1
+			@o2.quality_value([-2])
+			@o2.current_version.must_equal 10 # New min value for sum objective => +1
+			@o2.quality_value([1,2,3])
+			@o2.current_version.must_equal 12 # New max for both objectives => +1
+		end
+	end
+end

data/test/test_optimize_populationbasedoptimizer.rb

@@ -0,0 +1,24 @@
+require 'feldtruby/optimize/optimizer'
+
+class TestPopulationBasedOptimizer < MiniTest::Unit::TestCase
+	def setup
+		@o1 = MinimizeRMS.new
+		@pbo1 = FeldtRuby::Optimize::PopulationBasedOptimizer.new(@o1)	
+	end
+
+	def test_population_size
+		assert_equal 100, @pbo1.population_size
+	end
+
+	def test_sample_population_indices_without_replacement
+		100.times do
+			num_samples = rand_int(@pbo1.population_size)
+			sampled_indices = @pbo1.sample_population_indices_without_replacement(num_samples)
+			assert_equal num_samples, sampled_indices.length
+			assert_equal num_samples, sampled_indices.uniq.length, "Some elements where the same in #{sampled_indices.inspect}"
+			sampled_indices.each do |i|
+				assert i >= 0 && i < @pbo1.population_size
+			end
+		end
+	end
+end

data/test/test_optimize_random_search.rb

@@ -0,0 +1,46 @@
+require 'feldtruby/optimize/random_search'
+require 'feldtruby/array/basic_stats'
+
+
+unless defined?(MinimizeRMS)
+	class MinimizeRMS < FeldtRuby::Optimize::Objective
+		def objective_min_rms(candidate)
+			candidate.rms
+		end
+	end
+end
+
+unless defined?(MinimizeRMSAndSum)
+	class MinimizeRMSAndSum < MinimizeRMS
+		def objective_min_sum(candidate)
+			candidate.sum.abs
+		end
+	end
+end
+
+class TestRandomSearcher < MiniTest::Unit::TestCase
+	def setup
+		@s2 = FeldtRuby::Optimize::SearchSpace.new_symmetric(2, 1)
+		@s4 = FeldtRuby::Optimize::SearchSpace.new_symmetric(4, 1)
+
+		@o1 = MinimizeRMS.new
+		@o2 = MinimizeRMSAndSum.new
+
+		@rs1 = FeldtRuby::Optimize::RandomSearcher.new(@o1, @s2, {:verbose => false, :maxNumSteps => 1000})
+		@rs2 = FeldtRuby::Optimize::RandomSearcher.new(@o2, @s4, {:verbose => false, :maxNumSteps => 2187})
+	end
+
+	def test_random_search_for_small_vector_with_rms
+		@rs1.optimize()
+		# Very unlikely we get a number over 0.40 (2 elements) after 1000 steps...
+		assert @rs1.best.sum <= 0.40
+		assert_equal 1000, @rs1.num_optimization_steps
+	end
+
+	def test_random_search_for_small_vector_with_rms_and_sum_for_more_steps
+		@rs2.optimize()
+		# Very unlikely we get a number over 0.40 (3 elements)...
+		assert @rs2.best.sum <= 0.60
+		assert_equal 2187, @rs2.num_optimization_steps
+	end
+end

data/test/test_optimize_search_space.rb

@@ -0,0 +1,97 @@
+require 'minitest/spec'
+require 'feldtruby/optimize/search_space'
+
+describe "SearchSpace#bound" do
+	before do
+		@sp = FeldtRuby::Optimize::SearchSpace.new([-5, -3], [5, 7])
+	end
+
+	it "returns the values if they are INSIDE the search space boundaries" do
+		@sp.bound([-1, 0]).must_equal [-1, 0]
+	end
+
+	it "returns the values if they are ON the search space boundaries" do
+		@sp.bound([-5, -3]).must_equal 	[-5, -3]
+		@sp.bound([5, 7]).must_equal 		[5, 7]
+		@sp.bound([-5, 7]).must_equal 	[-5, 7]
+		@sp.bound([5, -3]).must_equal 	[5, -3]
+	end
+
+	it "generates a value INSIDE the search space boundaries when a value is given that is outside (negative, outside on one dimension)" do
+		l, h = @sp.bound([-10, 3.4])
+		h.must_equal 3.4
+		l.must_be :>=, -5
+		l.must_be :<=,  5
+
+		l, h = @sp.bound([-4.6, -4.1])
+		l.must_equal(-4.6)
+		h.must_be :>=, -3
+		h.must_be :<=,  7
+	end
+
+	it "generates a value INSIDE the search space boundaries when a value is given that is outside (positive, outside on one dimension)" do
+		l, h = @sp.bound([6, 2.7])
+		h.must_equal 2.7
+		l.must_be :>=, -5
+		l.must_be :<=,  5
+
+		l, h = @sp.bound([-4.6, 8.4])
+		l.must_equal(-4.6)
+		h.must_be :>=, -3
+		h.must_be :<=,  7
+	end
+
+	it "generates a value INSIDE the search space boundaries when a value is given that is outside (positive, outside on one dimension)" do
+		l, h = @sp.bound([-60.2, 1])
+		l.must_be :>=, -5
+		l.must_be :<=,  5
+		h.must_be :>=, -3
+		h.must_be :<=,  7
+	end
+end
+
+class TestSearchSpace < MiniTest::Unit::TestCase
+	def setup
+		@s1 = FeldtRuby::Optimize::SearchSpace.new([-5], [5])	
+		@s2 = FeldtRuby::Optimize::SearchSpace.new([-1, -1], [1, 1])	
+		@s3 = FeldtRuby::Optimize::SearchSpace.new([-1, -5, -100], [1, 50, 1000])	
+		@s4 = FeldtRuby::Optimize::SearchSpace.new_symmetric(4, 10)
+	end
+
+	def test_num_variables
+		assert_equal 1, @s1.num_variables
+		assert_equal 2, @s2.num_variables
+		assert_equal 3, @s3.num_variables
+		assert_equal 4, @s4.num_variables
+	end
+
+	def assert_gen_candidate_and_is_candidate(ss, numRepetitions = 100)
+		numRepetitions.times do
+			c = ss.gen_candidate()
+			assert_equal ss.num_variables, c.length
+			c.length.times do |i| 
+				assert ss.min_values[i] <= c[i]
+				assert ss.max_values[i] >= c[i]
+			end
+			assert ss.is_candidate?(c)
+		end
+	end
+
+	def test_gen_candidate_and_is_candidate
+		assert_gen_candidate_and_is_candidate(@s1)
+		assert_gen_candidate_and_is_candidate(@s2)
+		assert_gen_candidate_and_is_candidate(@s3)
+		assert_gen_candidate_and_is_candidate(@s4)
+	end
+
+	def test_new_from_min_max
+		ss = FeldtRuby::Optimize::SearchSpace.new_from_min_max(2, -7, 2)
+		assert_equal 2, ss.num_variables
+	end
+
+	def test_bound_returns_vector_if_supplied_a_vector
+		s1 = FeldtRuby::Optimize::SearchSpace.new([-5, -3], [5, 7])
+		b = s1.bound(Vector[-10, 5])
+		assert Vector, b.class
+	end
+end

data/test/test_time.rb

@@ -0,0 +1,27 @@
+require 'feldtruby/time'
+
+class TestFeldtRubyTime < MiniTest::Unit::TestCase
+	def test_timestamp_short
+		str = Time.timestamp({:short => true})
+		assert_equal 15, str.length
+		assert str =~ /^\d{6} \d{2}:\d{2}\.\d{2}/
+	end
+
+	def test_timestamp_long
+		str = Time.timestamp()
+		assert_equal 17, str.length
+		assert str =~ /^\d{8} \d{2}:\d{2}\.\d{2}/
+	end
+
+	def test_human_readable_timestr
+		assert_equal "74.92usec", Time.human_readable_timestr(0.000074916)
+		assert_equal "0.75msec", Time.human_readable_timestr(0.00074916)
+		assert_equal "7.49msec", Time.human_readable_timestr(0.0074916)
+		assert_equal "74.92msec", Time.human_readable_timestr(0.074916)
+		assert_equal "0.75sec", Time.human_readable_timestr(0.74916)
+		assert_equal "7.49sec", Time.human_readable_timestr(7.4916)
+		assert_equal "1.25mins", Time.human_readable_timestr(74.916)
+		assert_equal "12.49mins", Time.human_readable_timestr(749.16)
+		assert_equal "2.08hours", Time.human_readable_timestr(7491.6)
+	end
+end

data/test/test_vector.rb

@@ -0,0 +1,98 @@
+require 'helper'
+require 'feldtruby/vector'
+
+class TestVectorBasicStats < MiniTest::Unit::TestCase
+	def test_sum_normal
+		assert_equal 3, Vector[1,2].sum
+		assert_equal 6, Vector[1,2,3].sum
+	end
+
+	def test_sum_one_element
+		assert_equal 1, Vector[1].sum
+	end
+
+	def test_sum_empty_array
+		assert_equal 0, Vector[].sum
+	end
+
+	def test_mean_normal
+		assert_equal 1.5, Vector[1,2].mean
+		assert_equal 2,   Vector[1,2,3].mean
+	end
+
+	def test_mean_one_element
+		assert_equal 1, Vector[1].mean
+	end
+
+	def test_mean_empty_array
+		assert_equal 0, Vector[].mean
+	end
+
+	def test_mean_from_wikipedia_def_page_for_stdev
+		assert_equal 2.0, Vector[2, 4, 4, 4, 5, 5, 7, 9].stdev 
+	end
+
+	def test_root_mean_square
+		assert_equal Math.sqrt((1*1 + 2*2)/2.0), Vector[1, 2].root_mean_square
+		assert_equal Math.sqrt((10*10 + 243*243)/2.0), Vector[10, 243].rms
+	end
+
+	def test_weighted_sum_one_element
+		assert_equal 1, Vector[1].weighted_sum([1])
+		assert_equal 2, Vector[1].weighted_sum([2])
+	end
+
+	def test_weighted_sum_two_elements
+		assert_equal 3, 	Vector[1, 2].weighted_sum([1, 1])
+		assert_equal 22, 	Vector[1, 4].weighted_sum([2, 5])
+	end
+
+	def test_weighted_mean_one_elements
+		assert_equal 1, 	Vector[1].weighted_mean([1])
+		assert_equal 4, 	Vector[4].weighted_mean([2])
+	end
+
+	def test_weighted_mean_two_elements
+		assert_equal 1.5, 		Vector[1, 2].weighted_mean([1, 1])
+		assert_equal 22.0/7, 	Vector[1, 4].weighted_mean([2, 5])
+
+		assert_equal 1.5, 		Vector[1, 2].weighted_mean()
+	end
+end
+
+describe Vector do
+	describe "Slicing a vector" do
+		before do
+			@v = Vector[1,2,3,4,5] 
+		end
+
+		it "does not mess up normal indexing" do
+			@v[0].must_equal 1
+			@v[1].must_equal 2
+			@v[2].must_equal 3
+			@v[3].must_equal 4
+			@v[4].must_equal 5
+		end
+
+		it "works in the middle of a vector" do
+			@v[1,1].must_equal Vector[2]
+			@v[1,2].must_equal Vector[2,3]
+			@v[2,3].must_equal Vector[3,4,5]
+		end
+
+		it "works at the start of a vector" do
+			@v[0,1].must_equal Vector[1]
+			@v[0,2].must_equal Vector[1,2]
+			@v[0,5].must_equal Vector[1,2,3,4,5]
+		end
+
+		it "works at the end of a vector" do
+			@v[4,1].must_equal Vector[5]
+		end
+
+		it "works even if goes past the vector" do
+			@v[4,2].must_equal Vector[5]
+			@v[4,10].must_equal Vector[5]
+		end
+	end
+end

data/test/test_word_counter.rb

@@ -0,0 +1,57 @@
+require 'minitest/spec'
+require 'feldtruby/word_counter'
+
+describe "WordCounter" do
+  it "can count words" do
+    wc = FeldtRuby::WordCounter.new
+    wc.count_words "The fox likes running. The fox likes it. It feels good for the fox."
+    wc.words.sort.must_equal ["feels", "fox", "good", "likes", "running"]
+    wc.count("feels").must_equal 1
+    wc.count("fox").must_equal 3
+    wc.count("good").must_equal 1
+    wc.count("likes").must_equal 2
+    wc.count("running").must_equal 1
+
+    wc.count("notinthere").must_equal 0
+  end
+
+  it "can return a top list of most common words" do
+    wc = FeldtRuby::WordCounter.new
+    wc.count_words "The fox likes running. The fox likes it. It feels good for the fox."
+    t = wc.top_words(1)
+    t.must_be_instance_of Array
+    t.must_equal [["fox", 3]]
+    wc.top_words(2).must_equal [["fox", 3], ["likes", 2]]
+  end
+
+  it "can merge words that are very close to each other (singularis/pluralis/-ing)" do
+    wc = FeldtRuby::WordCounter.new
+    wc.count_words "test tests testing testing program programs programs design"
+    wc.merge!
+
+    wc.count("test|tests|testing").must_equal 4
+    wc.count("program|programs").must_equal 3
+    wc.count("design").must_equal 1
+  end
+
+  it "has merged word descriptions in the top list" do
+    wc = FeldtRuby::WordCounter.new
+    wc.count_words "test tests testing testing program programs programs"
+    wc.merge!
+
+    wc.top_words(2).must_equal [["test|tests|testing", 4], ["program|programs", 3]]
+  end
+end
+
+describe "NgramWordCounter" do
+  it "counts all 2-grams" do
+    wc = FeldtRuby::NgramWordCounter.new(2)
+    wc.count_words "The fox likes running. The fox likes it. It feels good for the fox."
+
+    wc.words.sort.must_equal ["fox likes", "likes running", "feels good"].sort
+
+    wc.count("fox likes").must_equal 2
+    wc.count("likes running").must_equal 1
+    wc.count("feels good").must_equal 1
+  end
+end