feldtruby 0.3.18 → 0.4.0

data/lib/feldtruby/optimize/optimizer.rb

@@ -23,7 +23,7 @@ class Optimizer
 
 		# Must setup logger before setting options since verbosity of logger is
 		# an option!
-		setup_logger_and_distribute_to_instance_variables()
+		setup_logger_and_distribute_to_instance_variables(options)
 
 		initialize_options(@options)
 	end
@@ -35,11 +35,11 @@ class Optimizer
 
 	# Optimize the objective in the given search space. 
 	def optimize()
+		logger.log "Optimization with optimizer #{self.class.inspect} started"
 		@num_optimization_steps = 0
 		# Set up a random best since other methods require it
 		update_best([search_space.gen_candidate()])
 		begin
-			logger.log "Optimization with optimizer #{self.class.inspect} started"
 			while !termination_criterion.terminate?(self)
 				new_candidates = optimization_step()
 				@num_optimization_steps += 1
@@ -83,11 +83,10 @@ class Optimizer
 		if @best.nil? || @objective.is_better_than?(best_new, @best)
 			qb = @best.nil? ? nil : @objective.quality_of(@best)
 			logger.log_data :new_best, {
-				:new_best => best_new,
-				:new_quality_value => @objective.quality_of(best_new), 
-				:old_best => @best,
-				:old_quality_value => qb
-			}, "New best candidate found"
+				"New best" => best_new,
+				"New quality" => @objective.quality_of(best_new), 
+				"Old best" => @best,
+				"Old quality" => qb}, "Optimizer (step #{@num_optimization_steps}): New best solution found", true
 			@best = best_new
 			true
 		else
@@ -212,7 +211,7 @@ DefaultOptimizationOptions = {
 	:verbose => true,
 	:populationSize => 200,
 	:samplerClass => FeldtRuby::Optimize::RadiusLimitedPopulationSampler,
-	:samplerRadius => 10 # Max distance between individuals selected in same tournament
+	:samplerRadius => 8 # Max distance between individuals selected in same tournament.
 }
 
 def self.override_default_options_with(options)

data/lib/feldtruby/version.rb

@@ -1,3 +1,3 @@
 module FeldtRuby
-  VERSION = "0.3.18"
+  VERSION = "0.4.0"
 end

data/spikes/comparing_samplers_on_classic_optimization_functions/compare_samplers.rb

@@ -32,62 +32,6 @@ SamplerRadiuses = SamplerRadiuses1
 
 NumRepetitionsPerSampler = 5
 
-# This is Lévi function number 13 as stated on the page:
-#  http://en.wikipedia.org/wiki/Test_functions_for_optimization
-# It has a global minima at f(1,1) = 0. -10 <= x,y <= 10
-class MinLeviFunctionNum13 < FeldtRuby::Optimize::Objective
-  TwoPi = 2*Math::PI
-  ThreePi = 3*Math::PI
-
-  def objective_min_levi13(candidate)
-    x, y = candidate[0], candidate[1]
-    sin_3pi_x = Math.sin(ThreePi * x)
-    sin_3pi_y = Math.sin(ThreePi * y)
-    sin_2pi_y = Math.sin(TwoPi * y)
-    x_min1 = x - 1.0
-    y_min1 = y - 1.0
-
-    (sin_3pi_x * sin_3pi_x) + 
-      (x_min1 * x_min1) * (1 + (sin_3pi_y * sin_3pi_y)) +
-      (y_min1 * y_min1) * (1 + (sin_3pi_y * sin_2pi_y))
-  end
-end
-
-# This is Beale's function as stated on the page:
-#  http://en.wikipedia.org/wiki/Test_functions_for_optimization
-# It has a global minima at f(3,0.5) = 0. -4.5 <= x,y <= 4.5
-class MinBealeFunction < FeldtRuby::Optimize::Objective
-  def objective_min_beales_func(candidate)
-    x, y = candidate[0], candidate[1]
-
-    t1 = 1.5 - x + (x*y)
-    t2 = 2.25 - x + (x*y*y)
-    t3 = 2.625 - x + (x*y*y*y)
-
-    (t1*t1) + (t2*t2) + (t3*t3)
-  end
-end
-
-# This is Easom's function as stated on the page:
-#  http://en.wikipedia.org/wiki/Test_functions_for_optimization
-# It has a global minima at f(3,0.5) = 0. -4.5 <= x,y <= 4.5
-class MinEasomFunction < FeldtRuby::Optimize::Objective
-  def objective_min_easom_func(candidate)
-    x, y = candidate[0], candidate[1]
-
-    f1 = Math.cos(x)
-
-    f2 = Math.cos(y)
-
-    x_min_pi = x - Math::PI
-    y_min_pi = y - Math::PI
-
-    f3 = Math.exp(-(x_min_pi*x_min_pi + y_min_pi*y_min_pi))
-
-    (-f1) * f2 * f3
-  end
-end
-
 # EggHolder function as stated on the page:
 #  http://en.wikipedia.org/wiki/Test_functions_for_optimization
 class MinEggHolderFunction < FeldtRuby::Optimize::Objective
@@ -105,26 +49,6 @@ class MinEggHolderFunction < FeldtRuby::Optimize::Objective
   end
 end
 
-class MinFunctionOfDimension < FeldtRuby::Optimize::Objective
-  attr_accessor :dimension
-  def minimum
-    0.0
-  end
-  def min_solutions
-    @min_solutions ||= ([[0.0] * dimension])
-  end
-end
-
-# Sphere function as stated in the JADE paper:
-#  http://150.214.190.154/EAMHCO/pdf/JADE.pdf
-class MinSphere < MinFunctionOfDimension
-  def objective_min_func(x)
-    x.inject(0.0) do |sum, xi|
-      sum + (xi*xi)
-    end
-  end
-end
-
 # Schwefel 2.22 function as stated in the JADE paper:
 #  http://150.214.190.154/EAMHCO/pdf/JADE.pdf
 class MinSchwefel2_22 < MinFunctionOfDimension

data/test/helper.rb

@@ -2,8 +2,13 @@ require 'rubygems'
 require 'minitest/autorun'
 require 'minitest/spec'
 
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
+FeldtRubyTestDir = File.dirname(__FILE__)
+FeldtRubyLibDir = File.join(FeldtRubyTestDir, '..', 'lib')
+FeldtRubyLongTestDir = File.join(FeldtRubyTestDir, 'long_running')
+
+$LOAD_PATH.unshift FeldtRubyLibDir
+$LOAD_PATH.unshift FeldtRubyTestDir
+$LOAD_PATH.unshift FeldtRubyLongTestDir
 
 require 'feldtruby'
 require 'feldtruby/minitest_extensions'

data/test/long_running/multi_objective_problems.rb

@@ -0,0 +1,58 @@
+require File.join(File.dirname(__FILE__), "single_objective_problems")
+
+class MinMulti2ObjectiveFuncOfDimensions < MinFuncOfDimensionObj
+  def minimum1
+    0.0
+  end
+
+  def minimum2
+    0.0
+  end
+
+  # Known optima that gives the minimum value.
+  def min_solutions
+    @min_solutions ||= ([[0.0] * dimension])
+  end
+
+  def objective_min_func1(x)
+    calc_func1(x) - minimum1
+  end
+
+  def objective_min_func2(x)
+    calc_func2(x) - minimum2
+  end
+
+  def calc_func1(x)
+    raise NotImplementedError
+  end
+
+  def calc_func2(x)
+    raise NotImplementedError
+  end
+end
+
+
+# This is the OmniTest bi-criteria test function as described in the paper:
+#  Shir et al, "Enhancing Decision Space Diversity in Evolutionary Multiobjective Algorithms", 2009.
+# They used dimensions == 5.
+class MinOmniTest < MinFuncOfDimensionObj
+  def domain_per_dimension
+    [0.0, 6.0]
+  end
+
+  def minimum1
+    @minimum1 ||= (-1 * dimensions)
+  end
+
+  def minimum2
+    @minimum2 ||= (-1 * dimensions)
+  end
+
+  def calc_func1(x)
+    x.map {|xi| Math.sin(Math::PI * xi)}.sum
+  end
+
+  def calc_func2(x)
+    x.map {|xi| Math.cos(Math::PI * xi)}.sum
+  end
+end

data/test/long_running/single_objective_problems.rb

@@ -0,0 +1,163 @@
+require 'feldtruby/optimize/search_space'
+
+class MinContinousFunction < FeldtRuby::Optimize::Objective
+  # Subclasses should fix this value.
+  def dimensions
+    @dimensions
+  end
+
+  # Domain (min, max) per dimension. Override this (or just override 
+  # search_space or domain_as_mins_maxs directly) so that a typical/valid 
+  # search space can be created.
+  def domain_per_dimension
+    raise NotImplementedError
+  end
+
+  # For more complex domains sub-classes can override this method.
+  def domain_as_mins_maxs
+    [domain_per_dimension] * self.dimensions
+  end
+
+  # Create a valid search space. Default is to use the domain_per_dimension
+  # a dimension number of times.
+  def search_space
+    FeldtRuby::Optimize::SearchSpace.new_from_min_max_per_variable domain_as_mins_maxs
+  end
+end
+
+class MinSingleObjectiveFunc < MinContinousFunction
+  # Known minimum (or nil if not known). Default is at 0.0.
+  def minimum
+    0.0
+  end
+
+  # Known optima that gives the minimum value. Default is that it is at 0,...,0.
+  def min_solutions
+    @min_solutions ||= ([[0.0] * dimensions])
+  end
+
+  def objective_min_func(x)
+    calc_func(x) - minimum
+  end
+
+  # Subclasses must implement this which is the function to be minimized.
+  def calc_func(x)
+    raise NotImplementedError
+  end
+end
+
+# Objectives that minimizes a function which is parameterized on a dimension
+# parameter should include this module.
+module MinFuncOfDimensionObj
+  attr_writer :dimensions
+end
+
+class MinSingleObjectiveFuncOfDimensions < MinSingleObjectiveFunc
+  include MinFuncOfDimensionObj
+end
+
+# Sphere function as stated in the JADE paper:
+#  http://150.214.190.154/EAMHCO/pdf/JADE.pdf
+class MinSphere < MinSingleObjectiveFuncOfDimensions
+  def calc_func(x)
+    x.inject(0.0) do |sum, xi|
+      sum + (xi*xi)
+    end
+  end
+
+  def domain_per_dimension
+    [-100, 100]
+  end
+end
+
+class Min2DSingleObjectiveFunc < MinSingleObjectiveFunc
+  def dimensions
+    2
+  end
+end
+
+# This is Lévi function number 13 as stated on the page:
+#  http://en.wikipedia.org/wiki/Test_functions_for_optimization
+# It has a global minima at f(1,1) = 0. -10 <= x,y <= 10
+class MinLevi13 < Min2DSingleObjectiveFunc
+  def min_solutions
+    [[1.0, 1.0]]
+  end
+
+  def domain_per_dimension
+    [-10.0, 10.0]
+  end
+
+  TwoPi = 2*Math::PI
+  ThreePi = 3*Math::PI
+
+  def calc_func(candidate)
+    x, y = candidate[0], candidate[1]
+
+    sin_3pi_x = Math.sin(ThreePi * x)
+    sin_3pi_y = Math.sin(ThreePi * y)
+    sin_2pi_y = Math.sin(TwoPi * y)
+    x_min1 = x - 1.0
+    y_min1 = y - 1.0
+
+    (sin_3pi_x * sin_3pi_x) + 
+      (x_min1 * x_min1) * (1 + (sin_3pi_y * sin_3pi_y)) +
+      (y_min1 * y_min1) * (1 + (sin_3pi_y * sin_2pi_y))
+  end
+end
+
+# This is Beale's function as stated on the page:
+#  http://en.wikipedia.org/wiki/Test_functions_for_optimization
+class MinBeale < Min2DSingleObjectiveFunc
+  def min_solutions
+    [[3.0, 0.5]]
+  end
+
+  def domain_per_dimension
+    [-4.5, 4.5]
+  end
+
+  def calc_func(candidate)
+    x, y = candidate[0], candidate[1]
+
+    t1 = 1.5 - x + (x*y)
+    t2 = 2.25 - x + (x*y*y)
+    t3 = 2.625 - x + (x*y*y*y)
+
+    (t1*t1) + (t2*t2) + (t3*t3)
+  end
+end
+
+# This is Easom's function as stated on the page:
+#  http://en.wikipedia.org/wiki/Test_functions_for_optimization
+class MinEasom < Min2DSingleObjectiveFunc
+  def minimum
+    -1.0
+  end
+
+  PI = Math::PI
+
+  def min_solutions
+    [[PI, PI]]
+  end
+
+  def domain_per_dimension
+    [-100.0, 100.0]
+  end
+
+  def calc_func(candidate)
+    x, y = candidate[0], candidate[1]
+
+    f1 = Math.cos(x)
+
+    f2 = Math.cos(y)
+
+    x_min_pi = x - PI
+    y_min_pi = y - PI
+
+    f3 = Math.exp(-(x_min_pi*x_min_pi + y_min_pi*y_min_pi))
+
+    (-f1) * f2 * f3
+  end
+end
+

data/test/long_running/test_single_objective_optimization.rb

@@ -0,0 +1,112 @@
+require File.join(FeldtRubyLongTestDir, "single_objective_problems")
+require 'feldtruby/optimize/differential_evolution'
+include FeldtRuby::Optimize
+
+module MiniTest::Assertions
+  # Assert that _bestSolution_ is close to at least one of the solutions that minimize
+  # the _objective_. We use the minimum RMS distance to the solutions, which should
+  # be close to zero for at least one solution.
+  def assert_close_to_one_solution(objective, bestSolution, precision = 0.01, msg = nil)
+    rmss = objective.min_solutions.map do |min_solution|
+      bestSolution.to_a.rms_from(min_solution)
+    end
+    # The minimum RMS to a solution must be close to zero.
+    rmss.min.must_be_close_to 0.0, precision
+  end
+end
+
+module MiniTest::Expectations
+  infect_an_assertion :assert_close_to_one_solution, :must_be_close_to_one_solution_of
+end
+
+describe "Sphere function" do
+  def best_from_de_on_sphere(dimensions, numSteps = 25_000, verbose = false)
+    sphere = MinSphere.new
+    sphere.dimensions = dimensions
+    ss = sphere.search_space
+    de = DEOptimizer.new(sphere, ss, {:verbose => verbose, 
+      :maxNumSteps => numSteps})
+    best = de.optimize().to_a
+    return best, sphere
+  end
+
+  it 'can optimize the Sphere function in 3 dimensions' do
+    best, sphere3 = best_from_de_on_sphere 3, 15_000
+
+    val = sphere3.calc_func(best)
+    val.must_be_close_to 0.0
+    val.must_be :>, 0.0
+
+    best.must_be_close_to_one_solution_of sphere3
+  end
+
+  it 'can optimize the Sphere function in 10 dimensions' do
+    best, sphere10 = best_from_de_on_sphere 10, 60_000
+
+    val = sphere10.calc_func(best)
+    val.must_be_close_to 0.0
+    val.must_be :>=, 0.0
+
+    best.must_be_close_to_one_solution_of sphere10
+  end
+
+  it 'can optimize the Sphere function in 30 dimensions' do
+    best, obj = best_from_de_on_sphere 30, 210_000
+
+    val = obj.calc_func(best)
+    val.must_be_close_to 0.0
+    val.must_be :>=, 0.0
+
+    # We don't test closeness since it might take very long for 30D to get close on all dimensions.
+  end
+end
+
+describe "Levi13 function" do
+  it 'can optimize the Levi13 function' do
+    objective = MinLevi13.new
+    ss = objective.search_space
+    de = DEOptimizer.new(objective, ss, {:verbose => false, 
+      :maxNumSteps => 7_500})
+    best = de.optimize().to_a
+
+    val = objective.calc_func(best)
+    val.must_be_close_to objective.minimum
+    val.must_be :>=, objective.minimum
+
+    best.must_be_close_to_one_solution_of objective, 0.01
+  end
+end
+
+describe "Beale function" do
+  it 'can optimize the Beale function' do
+    objective = MinBeale.new
+    ss = objective.search_space
+    de = DEOptimizer.new(objective, ss, {:verbose => false, 
+      :maxNumSteps => 7_500})
+    best = de.optimize().to_a
+
+    val = objective.calc_func(best)
+    val.must_be_close_to objective.minimum
+    val.must_be :>=, objective.minimum
+
+    best.must_be_close_to_one_solution_of objective, 0.01
+  end
+end
+
+describe "Easom function" do
+  it 'can optimize the Easom function' do
+    objective = MinEasom.new
+    ss = objective.search_space
+    # Why can't we do this in 25_000 evals anymore? We did it before. Repeatedly. Very strange.
+    de = DEOptimizer.new(objective, ss, {:verbose => true, 
+      :maxNumSteps => 25_000, :printFrequency => 0.0, 
+      :samplerRadius => 5})
+    best = de.optimize().to_a
+
+    val = objective.calc_func(best)
+    val.must_be_close_to objective.minimum
+    val.must_be :>=, objective.minimum
+
+    best.must_be_close_to_one_solution_of objective, 0.01
+  end
+end

data/test/test_array_basic_stats.rb

@@ -32,11 +32,6 @@ class TestArrayBasicStats < MiniTest::Unit::TestCase
 		assert_equal 2.0, [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), [1, 2].root_mean_square
-		assert_equal Math.sqrt((10*10 + 243*243)/2.0), [10, 243].rms
-	end
-
 	def test_weighted_sum_one_element
 		assert_equal 1, [1].weighted_sum([1])
 		assert_equal 2, [1].weighted_sum([2])
@@ -88,15 +83,28 @@ describe "Basic statistics" do
 		end
 	end
 
-	describe "rms_from_scalar" do
-		it "is the same as rms if scalar is 0.0" do
-			a = [1,2,3,4,5]
-			a.rms_from_scalar(0.0).must_be_within_delta a.rms
+	describe "Root mean square" do
+		it 'can calculate the RMS on an array of numbers' do
+			[1, 2].root_mean_square.must_equal Math.sqrt((1*1 + 2*2)/2.0)
+			[10, 243].rms.must_equal Math.sqrt((10*10 + 243*243)/2.0)
+		end
+
+		describe "rms_from_scalar" do
+			it "is the same as rms if scalar is 0.0" do
+				a = [1,2,3,4,5]
+				a.rms_from_scalar(0.0).must_be_within_delta a.rms
+			end
+	
+			it "is correct for concrete example" do
+				a = [1,2]
+				a.rms_from_scalar(1.5).must_equal Math.sqrt( (0.5**2 + 0.5**2)/2 )
+			end
 		end
 
-		it "is correct for concrete example" do
-			a = [1,2]
-			a.rms_from_scalar(1.5).must_equal Math.sqrt( (0.5**2 + 0.5**2)/2 )
+		it 'can calculate the rms between two arrays' do
+			a = [1, 2, 3]
+			b = [2, 4, 7]
+			a.rms_from(b).must_equal Math.sqrt((1-2)**2 + (2-4)**2 + (3-7)**2)
 		end
 	end
 

data/test/test_logger.rb

@@ -6,7 +6,7 @@ describe 'Logger' do
   before do
     @sio = StringIO.new
     @l = FeldtRuby::Logger.new @sio, {:verbose => true, 
-      :print_frequency => 0.0 # So everything is logged
+      :printFrequency => 0.0 # So everything is logged
     }
   end
 
@@ -55,7 +55,7 @@ describe 'Logger with a non-zero print frequency' do
   before do
     @sio = StringIO.new
     @l = FeldtRuby::Logger.new @sio, {:verbose => true, 
-      :print_frequency => 0.1
+      :printFrequency => 0.1
     }
   end
 
@@ -96,7 +96,7 @@ describe 'Logger with two IO output streams' do
   it 'logs to all streams of more than one' do
     sio1 = StringIO.new
     l = FeldtRuby::Logger.new sio1, {:verbose => true, 
-      :print_frequency => 0.0
+      :printFrequency => 0.0
     }
     sio2 = StringIO.new
     l.add_io sio2
@@ -118,7 +118,7 @@ describe 'Logger with two IO output streams' do
   it 'can add filenames to which log output should be written' do
     sio1 = StringIO.new
     l = FeldtRuby::Logger.new sio1, {:verbose => true, 
-      :print_frequency => 0.0
+      :printFrequency => 0.0
     }
 
     filename = "temp390580943850834.log"