feldtruby 0.2.0

data/lib/feldtruby/optimize/differential_evolution.rb

@@ -0,0 +1,186 @@
+require 'feldtruby/optimize/optimizer'
+require 'feldtruby/math/rand'
+require 'feldtruby/vector'
+
+module FeldtRuby::Optimize
+
+# Common to many Evolutionary Computation optimizers
+class EvolutionaryOptimizer < PopulationBasedOptimizer; end
+
+# Base class for Differential Evolution (DE) for continuous, real-valued optimization.
+# Since there are many different DE variants this is the base class
+# from which we can then include different strategy parts and create complete DE classes.
+#
+# A DE strategy generates a new trial vector as a candidate to replace a parent vector.
+# It is composed of four parts:
+#  - a mutation strategy that samples a set of parents to create a donor vector
+#  - a crossover strategy which takes a donor and parent vector and creates a trial vector
+#  - a bounding strategy which ensures the trial vector is within the search space
+#  - an update strategy which can be used to self-adapt parameters based on feedback on improvements
+#
+# A strategy gets feedback on whether the latest trial vector was an improvement. It
+# can use this feedback to adapt its operation over time.
+#
+# We implement strategies as Ruby Module's that we can include in different DE optimizer classes
+# that inherits form the base one above. For maximum flexibility, each of the four parts of
+# a DE strategy are implemented in separate Module's so we can mix and match them.
+class DEOptimizerBase < EvolutionaryOptimizer
+	DefaultOptions = {
+		:DE_F_ScaleFactor 			=> 0.7,
+		:DE_CR_CrossoverRate 		=> 0.5,
+		:DE_NumParentsToSample	=> 4,
+	}
+
+	def initialize_options(options)
+		super
+		@options = DefaultOptions.clone.update(options)
+		@f = @scale_factor = @options[:DE_F_ScaleFactor]
+		@cr = @crossover_rate = @options[:DE_CR_CrossoverRate]
+		@num_parents_to_sample = @options[:DE_NumParentsToSample]
+	end
+
+	# Create a population of a given size by randomly sampling candidates from the search space
+	# and converting them to Vector's so we can more easily calculate on them later.
+	def initialize_population(sizeOfPopulation)
+		@population = Array.new(sizeOfPopulation).map {Vector.elements(search_space.gen_candidate())}
+	end
+
+	# Create a candidate from an array. By default we represent candidates with Ruby
+	# vectors since they allow vector-based artihmetic.
+	def candidate_from_array(ary)
+		Vector.elements(ary)
+	end
+
+	# One step of the optimization is to (try to) update one vector. Thus, this is more of
+	# a steady-state than a generational EC. DE is typically a generational EC but it is hard
+	# to see any reason why. The default DE here is the classic DE/rand/1/*
+	def optimization_step()
+		trial, target, target_index = generate_trial_candidate_and_target()
+
+		# We get [candidate, qualityValue, subQualityValues] for each vector
+		best, worst = objective.rank_candidates([target, trial])
+
+		# Supplant the target vector with the trial vector if better
+		if best.first != target
+			@logger.note_new_better("Trial vector was better", *best)
+			trial_better = true
+			update_candidate_in_population(target_index, trial)
+		else
+			trial_better = false
+		end
+
+		# Give feedback to strategy since some strategies use this to self-adapt
+		feedback_on_trial_vs_target(trial, target, trial_better)
+
+		[best.first]
+	end
+
+	#####################################
+	# Strategy-related methods. Can be overridden by strategies later. Below are the defaults.
+  #####################################
+
+	# Number of parents to sample. Default is that this is constant but can be overriden by
+	# a mutation strategy.
+	def num_parents_to_sample; options[:DE_NumParentsToSample]; end
+
+	# Scale factor F.
+	# Default is to use the one set in the optimizer, regardless of target vector.
+	def scale_factor(targetVectorIndex); @f; end
+
+	# Crossover rate. Default is to use the one set in the optimizer, regardless of position 
+	# of the crossover position.
+	def crossover_rate(position); @cr; end
+
+	# Sample parents from the population and return their indices.
+	def sample_parents()
+		sample_population_indices_without_replacement(num_parents_to_sample)
+	end
+
+	# Main entry point for a DEStrategy. Generates a new trial vector and the parent
+	# it targets.
+	def generate_trial_candidate_and_target()
+		# Sample parents. The first parent returned is used as target parent to cross-over with. 
+		# Rest of the sampled parents is/can be used in mutation.
+		target_parent_index, *parent_indices = sample_parents()
+		target = get_candidate(target_parent_index)
+
+		# The three main steps. We get feedback from optimizer at a later stage.
+		donor = mutate(target_parent_index, parent_indices) # Should be implemented by a MutationStrategy
+		trial = crossover_donor_and_target(target, donor, 
+							target_parent_index) 											# Should be implemented by a CrossoverStrategy
+		trial = bound_trial_candidate(trial)								# Should be implemented by a BoundingStrategy
+
+		return trial, target, target_parent_index
+	end
+end
+
+module DE_BoundingStrategy_RandomWithinSearchSpace
+	# Default bounding strategy is to bound by the search space.
+	def bound_trial_candidate(candidate)
+		search_space.bound(candidate)
+	end
+end
+
+module DE_UpdateStrategy_NoFeedbackUpdates
+	# We can use feedback from optimizer to improve. Default is to not change anything.
+	def feedback_on_trial_vs_target(trial, target, trialBetter); end
+end
+
+# This is the classic binomial DE/*/*/bin crossover.
+module DE_CrossoverStrategy_Binomial
+	def crossover_donor_and_target(targetVector, donorVector, targetVectorIndex)
+		num_variables = donorVector.size
+		jrand = rand_int(num_variables)
+		trial_vector = targetVector.clone.to_a		# We use the targetVector values as a starting point
+		trial_vector[jrand] = donorVector[jrand]	# Always copy one random var to ensure some difference.
+		num_variables.times do |j|
+			trial_vector[j] = donorVector[j] if rand() <= crossover_rate(j) # Copy with crossover_rate probability
+		end
+		candidate_from_array(trial_vector)
+	end
+end
+
+# Building block for mutation strategies.
+module DE_X_1_StrategyBuildingBlock
+	# We need 0 target parents and 2 other parents. Note that we must sample a target parent
+	# also even though it is not used in the mutation.
+	def num_parents_to_sample; 3; end
+
+	def difference_vector(donorParentsIndices)
+		p1, p2 = get_candidates_with_indices(donorParentsIndices)
+		(p1 - p2)
+	end
+end
+
+module DE_Rand_X_StrategyBuildingBlock
+	def mutate(targetIndex, donorParentsIndices)
+		p3 = get_candidate(donorParentsIndices[-1])
+		p3 + scale_factor(targetIndex) * difference_vector(donorParentsIndices[0...-1])
+	end
+end
+
+# The most-used DE/rand/1 mutation strategy.
+module DE_MutationStrategy_Rand_1
+	include DE_X_1_StrategyBuildingBlock
+
+	# We need one more parent in the Rand strategy than in the others, but
+	# we can reuse the difference vector generation. So partial reuse here
+	# NOTE! Order of inclusion is critical!!!
+	def num_parents_to_sample; 4; end
+
+	include DE_Rand_X_StrategyBuildingBlock
+end
+
+# The default DEOptimizer uses 
+#   Bounding  = random bouding within the search space
+#   Update 	  = no updates based on feedback
+#   Crossover = Classic binomial
+#   Mutation  = Rand-1
+class DEOptimizer < DEOptimizerBase
+	include DE_BoundingStrategy_RandomWithinSearchSpace
+	include DE_UpdateStrategy_NoFeedbackUpdates
+	include DE_CrossoverStrategy_Binomial
+	include DE_MutationStrategy_Rand_1
+end
+
+end

data/lib/feldtruby/optimize/max_steps_termination_criterion.rb

@@ -0,0 +1,24 @@
+require 'feldtruby/optimize'
+
+class FeldtRuby::Optimize::TerminationCriterion
+	# Default termination criterion is to never terminate
+	def terminate?(optimizer)
+		false
+	end
+
+	# Inverse of terminate?, i.e. should we continue optimizing?
+	def continue_optimization?
+		!terminate?
+	end
+end
+
+class FeldtRuby::Optimize::MaxStepsTerminationCriterion < FeldtRuby::Optimize::TerminationCriterion
+	attr_accessor :max_steps
+
+	def initialize(maxSteps = 1000)
+		@max_steps = maxSteps
+	end
+	def terminate?(optimizer)
+		optimizer.num_optimization_steps >= @max_steps
+	end
+end

data/lib/feldtruby/optimize/objective.rb

@@ -0,0 +1,302 @@
+
+require 'feldtruby/optimize'
+require 'feldtruby/float'
+
+# An Objective captures one or more objectives into a single object
+# and supports a large number of ways to utilize basic objective
+# functions in a single framework. You subclass and add instance
+# methods named as 
+#   objective_min_qualityAspectName (for an objective/aspect to be minimized), or 
+#   objective_max_qualityAspectName (for an objective/aspect to be minimized).
+# There can be multiple aspects (sub-objectives) for a single objective.
+# This base class uses mean-weighted-global-ratios (MWGR) as the default mechanism
+# for handling multi-objectives i.e. with more than one sub-objective. 
+# An objective has version numbers to indicate the number of times the scale 
+# for the calculation of the ratios has been changed.
+class FeldtRuby::Optimize::Objective
+	attr_accessor :current_version, :logger
+
+	def initialize
+		@logger = nil # To avoid getting warnings that logger has not been initialized
+		@current_version = 0
+		@pareto_front = Array.new(num_aspects)
+	end
+
+	def reset_quality_scale(candidate, aspectIndex, typeOfReset)
+		if (typeOfReset == :min && is_min_aspect?(aspectIndex)) || 
+		   (typeOfReset == :max && !is_min_aspect?(aspectIndex))
+			@pareto_front[aspectIndex] = candidate
+		end
+
+		# Reset the best object since we have a new scale
+		@best_candidate = nil
+		@best_qv = nil
+
+		inc_version_number
+	end
+
+	def update_best_candidate(candidate)
+		@best_candidate = candidate
+		@best_qv = candidate._quality_value
+	end
+
+	def inc_version_number
+		@current_version += 1
+	end
+
+	# Return the number of aspects/sub-objectives of this objective.
+	def num_aspects
+		@num_aspects ||= aspect_methods.length
+	end
+
+	# Class for representing multi-objective qualitites...
+	class QualityValue
+		attr_reader :qv, :sub_qvs
+
+		def initialize(qv, subQvs, objective)
+			@qv, @sub_qvs, @objective = qv, subQvs, objective
+			@version = objective.current_version
+		end
+
+		def <=>(other)
+			@qv <=> other.qv
+		end
+
+		# Two quality values are the same if they have the same qv, regardless of their
+		# sub qualities.
+		def ==(other)
+			other = other.qv if QualityValue === other
+			@qv == other
+		end
+
+		def improvement_in_relation_to(other)
+			if QualityValue === other
+				pdiff = @qv.ratio_diff_vs(other.qv)
+				subpdiffs = @sub_qvs.zip(other.sub_qvs).map {|s, os| s.ratio_diff_vs(os)}
+				qinspect(pdiff, subpdiffs, "Difference", "SubQ. differences", true) + ", #{report_on_num_differences(subpdiffs)}"
+			else
+				@qv.improvement_in_relation_to(other)
+			end
+		end
+
+		def report_on_num_differences(subQvRatioDiffs)
+			num_inc = subQvRatioDiffs.select {|v| v > 0}.length
+			num_dec = subQvRatioDiffs.select {|v| v < 0}.length
+			num_same = subQvRatioDiffs.length - num_inc - num_dec
+			"#{num_inc} increased, #{num_dec} decreased, #{num_same} same"
+		end
+
+		def qinspect(qv, subQvs, qvDesc = "Quality", subQvDesc = "SubQualities", subQvsAreRatios = false, qvIsRatio = true)
+			subQvs = subQvs.map {|v| v*100.0} if subQvsAreRatios
+			sqs = subQvs.map do |sqv| 
+				s = (Float === sqv ? sqv.round_to_decimals(4) : sqv).inspect
+				s += "%" if subQvsAreRatios
+				s
+			end.join(", ")
+			if qvIsRatio
+				qstr = ("%.4f" % (100.0 * qv)) + "%"
+			else
+				qstr = "%.4f" % qv
+			end
+			"#{qvDesc}: #{qstr}, #{subQvDesc}: [#{sqs}]"
+		end
+
+		def inspect
+			qinspect(@qv, @sub_qvs) + ", Obj. version: #{@version}"
+		end
+
+		# Refer all other methods to the main quality value
+		def method_missing(meth, *args, &block)
+			@qv.send(meth, *args, &block)
+      	end
+	end
+
+	# Return a single quality value for the whole objective for a given candidate. 
+	# By default this uses a variant of Bentley and Wakefield's sum-of-weighted-global-ratios (SWGR)
+	# called mean-of-weighted-global-ratios (MWGR) which always returns a fitness value
+	# in the range (0.0, 1.0) with 1.0 signaling the best fitness seen so far. The scale is adaptive
+	# though so that the best candidate so far always has a fitness value of 1.0.
+	def quality_value(candidate, weights = nil)
+		return candidate._quality_value_without_check if quality_value_is_up_to_date?(candidate)
+		num_aspects == 1 ? qv_single(candidate) : qv_mwgr(candidate, weights)
+	end
+
+	def quality_value_is_up_to_date?(candidate)
+		candidate._objective == self && candidate._objective_version == current_version
+	end
+
+	def update_quality_value_in_object(object, qv)
+		object._objective = self
+		object._objective_version = current_version
+		object._quality_value_without_check = qv
+	end
+
+	def ensure_updated_quality_value(candidate)
+		return if quality_value_is_up_to_date?(candidate)
+		quality_value(candidate)
+	end
+
+	def rank_candidates(candidates, weights = nil)
+		mwgr_rank_candidates(candidates, weights)
+	end
+
+	# Rand candidates from best to worst. NOTE! We do the steps of MWGR separately since we must
+	# update the global mins and maxs before calculating the SWG ratios.
+	def mwgr_rank_candidates(candidates, weights = nil)
+		sub_qvss = candidates.map {|c| sub_objective_values(c)}
+		sub_qvss.zip(candidates).each {|sub_qvs, c| update_global_mins_and_maxs(sub_qvs, c)}
+		sub_qvss.each_with_index.map do |sub_qvs, i|
+			qv = mwgr_ratios(sub_qvs).weighted_mean(weights)
+			qv = QualityValue.new(qv, sub_qvs, self)
+			update_quality_value_in_object(candidates[i], qv)
+			[candidates[i], qv, sub_qvs]
+		end.sort_by {|a| -a[1]} # sort by the ratio values in descending order
+	end
+
+	def note_end_of_optimization(optimizer)
+		log("Objective reporting the Pareto front", info_pareto_front())
+	end
+
+	def info_pareto_front
+		@pareto_front.each_with_index.map do |c, i|
+			"Pareto front candidate for objective #{aspect_methods[i]}: #{map_candidate_vector_to_candidate_to_be_evaluated(c).inspect}"
+		end.join("\n")
+	end
+
+	# Return the quality value assuming this is a single objective.
+	def qv_single(candidate)
+		qv = self.send(aspect_methods.first, 
+			map_candidate_vector_to_candidate_to_be_evaluated(candidate))
+		update_quality_value_in_object(candidate, qv)
+		qv
+	end
+
+	# Mean-of-weigthed-global-ratios (MWGR) quality value
+	def qv_mwgr(candidate, weights = nil)
+		mwgr_rank_candidates([candidate], weights).first[1]
+	end
+
+	# Calculate the SWGR ratios
+	def mwgr_ratios(subObjectiveValues)
+		subObjectiveValues.each_with_index.map {|v,i| ratio_for_aspect(i, v)}
+	end
+
+	def ratio_for_aspect(aspectIndex, value)
+		min, max = global_min_values_per_aspect[aspectIndex], global_max_values_per_aspect[aspectIndex]
+		if is_min_aspect?(aspectIndex)
+			numerator = max - value
+		else
+			numerator = value - min
+		end
+		numerator.to_f.protected_division_with(max - min)
+	end
+
+	# The vectors can be mapped to a more complex candidate object before we call
+	# the sub objectives to calc their quality values. Default is no mapping but subclasses
+	# can override this.
+	def map_candidate_vector_to_candidate_to_be_evaluated(vector)
+		vector
+	end
+
+	def sub_objective_values(candidateVector)
+		candidate = map_candidate_vector_to_candidate_to_be_evaluated(candidateVector)
+		aspect_methods.map {|omethod| self.send(omethod, candidate)}
+	end
+
+	def update_global_mins_and_maxs(aspectValues, candidate = nil)
+		aspectValues.each_with_index {|v, i| update_global_min_and_max(i, v, candidate)}
+	end
+
+	def update_global_min_and_max(aspectIndex, value, candidate)
+		min = global_min_values_per_aspect[aspectIndex]
+		if value < min
+			reset_quality_scale(candidate, aspectIndex, :min)
+			global_min_values_per_aspect[aspectIndex] = value
+			log_new_min_max(aspectIndex, value, min, "min")
+		end
+		max = global_max_values_per_aspect[aspectIndex]
+		if value > max
+			reset_quality_scale(candidate, aspectIndex, :max)
+			global_max_values_per_aspect[aspectIndex] = value
+			log_new_min_max(aspectIndex, value, max, "max")
+		end
+	end
+
+	def log_new_min_max(index, newValue, oldValue, description)
+		log("New global #{description} for sub-objective #{aspect_methods[index]}",
+			("a %.3f" % (100.0 * (newValue - oldValue).protected_division_with(oldValue))) + "% difference",
+			"new = #{newValue}, old = #{oldValue}",
+			"scale is now [#{global_min_values_per_aspect[index]}, #{global_max_values_per_aspect[index]}]",
+			"objective version = #{current_version}")
+	end
+
+	def log(msg, *values)
+		@logger.anote(msg, *values) if @logger
+	end
+
+	# Global min values for each aspect. Needed for SWGR. Updated every time we see a new
+	# quality value for an aspect.
+	# All are minus infinity when we have not seen any values yet.
+	def global_min_values_per_aspect
+		@global_min_values_per_aspect ||= Array.new(num_aspects).map {Float::INFINITY}
+	end
+
+	# Global max values for each aspect. Needed for SWGR. Updated every time we see a new
+	# quality value for an aspect.
+	# All are minus infinity when we have not seen any values yet.
+	def global_max_values_per_aspect
+		@global_max_values_per_aspect ||= Array.new(num_aspects).map {-Float::INFINITY}
+	end
+
+	private
+
+	def aspect_methods
+		@aspect_methods ||= self.methods.select {|m| is_aspect_method?(m)}
+	end
+
+	def is_min_aspect?(aspectIndex)
+		(@is_min_aspect ||= (aspect_methods.map {|m| is_min_aspect_method?(m)}))[aspectIndex]
+	end
+
+	def is_aspect_method?(methodNameAsSymbolOrString)
+		methodNameAsSymbolOrString.to_s =~ /^objective_(min|max)_([\w_]+)$/
+	end
+
+	def is_min_aspect_method?(methodNameAsSymbolOrString)
+		methodNameAsSymbolOrString.to_s =~ /^objective_min_([\w_]+)$/
+	end
+end
+
+# We add strangely named accessor methods so we can attach the quality values to objects.
+# We use strange names to minimize risk of method name conflicts.
+class Object
+	attr_accessor :_quality_value_without_check, :_objective, :_objective_version
+	def _quality_value
+		@_objective.ensure_updated_quality_value(self) if defined?(@_objective) && @_objective
+		@_quality_value_without_check ||= nil # To avoid warning if unset
+	end
+end
+
+# Short hand for when the objective function is given as a block that should be minimized.
+class FeldtRuby::Optimize::ObjectiveMinimizeBlock < FeldtRuby::Optimize::Objective
+	def initialize(&objFunc)
+		super()
+		@objective_function = objFunc
+	end
+
+	def objective_min_cost_function(candidate)
+		@objective_function.call(*candidate.to_a)
+	end
+end
+
+# Short hand for when the objective function is given as a block that should be minimized.
+class FeldtRuby::Optimize::ObjectiveMaximizeBlock < FeldtRuby::Optimize::Objective
+	def initialize(&objFunc)
+		super()
+		@objective_function = objFunc
+	end
+
+	def objective_max_cost_function(candidate)
+		@objective_function.call(*candidate.to_a)
+	end
+end

data/lib/feldtruby/optimize/optimizer.rb

@@ -0,0 +1,145 @@
+require 'feldtruby/optimize'
+require 'feldtruby/optimize/objective'
+require 'feldtruby/optimize/search_space'
+require 'feldtruby/optimize/stdout_logger'
+require 'feldtruby/optimize/max_steps_termination_criterion'
+require 'feldtruby/math/rand'
+
+module FeldtRuby::Optimize 
+	DefaultOptimizationOptions = {
+		:logger => FeldtRuby::Optimize::StdOutLogger,
+		:maxNumSteps => 10_000,
+		:terminationCriterionClass => FeldtRuby::Optimize::MaxStepsTerminationCriterion,
+		:verbose => false,
+		:populationSize => 100,
+	}
+
+	def self.override_default_options_with(options)
+		o = DefaultOptimizationOptions.clone.update(options)
+		o[:terminationCriterion] = o[:terminationCriterionClass].new(o[:maxNumSteps])
+		o
+	end
+end
+
+# Find an vector of float values that optimizes a given
+# objective.
+class FeldtRuby::Optimize::Optimizer
+	attr_reader :objective, :search_space, :best, :best_quality_value, :best_sub_quality_values, :num_optimization_steps, :termination_criterion
+
+	def initialize(objective, searchSpace = FeldtRuby::Optimize::DefaultSearchSpace, options = {})
+		@best = nil # To avoid warnings if not set
+		@objective, @search_space = objective, searchSpace
+		@options = FeldtRuby::Optimize.override_default_options_with(options)
+		initialize_options(@options)
+		@objective.logger = @logger
+	end
+
+	def initialize_options(options)
+		@logger = options[:logger].new(self, options[:verbose])
+		@termination_criterion = options[:terminationCriterion]
+	end
+
+	# Optimize the objective in the given search space. 
+	def optimize()
+		@num_optimization_steps = 0
+		# Set up a random best since other methods require it
+		update_best([search_space.gen_candidate()])
+		begin
+			@logger.note_optimization_starts()
+			while !termination_criterion.terminate?(self)
+				new_candidates = optimization_step()
+				@num_optimization_steps += 1
+				@logger.note_another_optimization_step(@num_optimization_steps)
+				update_best(new_candidates)
+			end
+		rescue Exception => e
+			@logger.note_termination("!!! - Optimization FAILED with exception: #{e.message} - !!!" + e.backtrace.join("\n"))
+		ensure	
+			@logger.note_termination("!!! - Optimization FINISHED after #{@num_optimization_steps} steps - !!!")
+		end
+		@objective.note_end_of_optimization(self)
+		@logger.note_end_of_optimization(self)
+		@best # return the best
+	end
+
+	# Run one optimization step. Default is to do nothing, i.e. this is just a superclass,
+	# but subclasses need to implement this.
+	def optimization_step()
+	end
+
+	# Rank all candidates, then update the best one if a new best found.
+	def update_best(candidates)
+		if @best
+			ranked = objective.rank_candidates(candidates + [@best])
+		else
+			ranked = objective.rank_candidates(candidates)
+		end
+		new_best, new_quality_value, new_sub_qvalues = ranked.first
+		# Since some objectives are not deterministic the best
+		if new_best != @best
+			if @best
+				old_best, new_qv_old_best, sub_qv_old_best = ranked.select {|a| a.first == @best}.first
+			end
+			@logger.note_new_best(new_best, new_quality_value, new_sub_qvalues, 
+				@best, new_qv_old_best, sub_qv_old_best)
+			@best = new_best
+			@best_quality_value = new_quality_value
+			@best_sub_quality_values = new_sub_qvalues
+			true
+		else
+			false
+		end
+	end
+end
+
+class FeldtRuby::Optimize::PopulationBasedOptimizer < FeldtRuby::Optimize::Optimizer
+	attr_reader :population
+
+	def initialize_options(options)
+		super
+		initialize_population(@options[:populationSize])
+		initialize_all_indices()
+	end
+
+	# Create a population of a given size by randomly sampling candidates from the search space.
+	def initialize_population(sizeOfPopulation)
+		@population = Array.new(sizeOfPopulation).map {search_space.gen_candidate()}
+	end
+
+	def population_size
+		@population.length
+	end
+
+	def initialize_all_indices
+		# We set up an array of the indices to all candidates of the population so we can later sample from it
+		# This should always contain all indices even if they might be out of order. This is because we
+		# only swap! elements in this array, never delete any.
+		@all_indices = (0...population_size).to_a
+	end
+
+	# Sample indices from the population without replacement.
+	def sample_population_indices_without_replacement(numSamples)
+		sampled_indices = []
+		numSamples.times do |i|
+			index = i + rand_int(population_size - i)
+			sampled_index, skip = @all_indices.swap!(i, index)
+			sampled_indices << sampled_index
+		end
+		sampled_indices
+	end
+
+	# Get candidates from population at given indices.
+	def get_candidates_with_indices(indices)
+		indices.map {|i| @population[i]}
+	end
+
+	# Get candidate from population at given index.
+	def get_candidate(index)
+		@population[index]
+	end
+
+	# Update population with candidate at given index.
+	def update_candidate_in_population(index, candidate)
+		@population[index] = candidate
+	end
+end

data/lib/feldtruby/optimize/random_search.rb

@@ -0,0 +1,9 @@
+require 'feldtruby/optimize/optimizer'
+
+# Random search that optimizes a given objective function.
+class FeldtRuby::Optimize::RandomSearcher < FeldtRuby::Optimize::Optimizer
+	def optimization_step()
+		# For random search we just generate a new random candidate in each step.
+		[search_space.gen_candidate()]
+	end
+end