metaheuristics 0.1.0

data/README.md

@@ -0,0 +1,122 @@
+
+Metaheustics
+============
+
+A ruby library of metaheuristics for search/optimisation.
+
+
+Usage
+-----
+
+For a given problem, the following must be implemented:
+ * a genome class (details below)
+ * a lambda taking no argument and producing a different randomly generated
+   genome each time it is called
+ * an evaluator lambda taking as argument a `genome` object, and returning a
+   fitness object which much implement the `Comparable` interface (usually
+   float is used)
+
+
+The genome class must implements the following methods:
+ * `clone()` return a deep copy of the genome
+ * `mutate!(mutation_rate)` mutates each gene of the genome with probability `mutation_rate`, return `self`
+ * `crossover(genome)` return a new genome which is a combination of this genome and the `genome` parameter
+
+
+    require 'metaheuristics/metaheuristic_init_factory'
+
+    search_definition = {
+      :name            => :tournament_selection,
+      :mutation_rate   => 0.1               # depends on the number of genes in a genome
+    }
+    
+    search_init = MetaheuristicInitFactory.from_definition(search_definition)
+    
+    search = search_init.call(
+      :genome_init => genome_init,          # the lambda generating random genomes
+      :evaluator   => evaluator_minimiser)  # the evaluator lambda
+
+     # run the search until the fitness is over 9000!
+     begin 
+       search.run_once
+     end while search.results.best[:fitness] <= 9000
+    
+
+A rule of thumb for the mutation rate is to aim for one mutation per genome, the
+mutation rate should then be the inverse of the number of genes in a genome.
+
+The file `examples/example_minimiser.rb` demonstrates usage for a simple minimisation problem.
+
+
+Implementing new algorithms
+---------------------------
+
+New algorithms should implement the `MetaheuristicInterface`, and be given an
+entry in `MetaheuristicInitFactory::from_definition()`. Then if you are happy
+with the licensing, please send me a pull request!
+
+
+Algorithms Details
+------------------
+
+At the moment `metaheuristics` contains only Genetic Algorithms (GAs), but has
+vocation to not only contain genome based methods, but also eventually
+array-of-values based methods.
+
+ * The traditional tournament selection.
+ * An implementation of the ALPS paradigm using tournament selection in the layers.
+ * FgrnGa, a GA in which fittest individual are kept in the population across several generations.
+ 
+If you don't know which one to use, ALPS is recommended.
+
+For more on metaheuristics, check out [Sean Luke's great
+book][http://cs.gmu.edu/~sean/book/metaheuristics/], available for download for
+free, or in printed paper form for money.
+
+
+
+### Tournament selection
+
+A simple, basic GA, where each parent is selected by taking a random sample
+of the population, and choosing the fittest individual in that sample.
+
+
+### Age-Layered Population Structure (ALPS)
+
+An implementation of the ALPS paradigm which aims to prevent premature
+convergence, combined here with tournament selection in the layers.
+[Greg Hornby's ALPS paper][http://idesign.ucsc.edu/papers/hornby_gecco06.pdf]
+
+
+### FgrnGa
+
+An implementation of a GA keeping fit parents across multiple generations.
+It has notably been used to evolve FGRN genomes, which explains the naming.
+A description is available in Peter Bentley's thesis.
+
+
+License
+-------
+
+This software is provided under an open source MIT-like license:
+
+Copyright (c) 2012 Jean-Baptiste Krohn <http://susano.org>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/examples/example_minimiser.rb

@@ -0,0 +1,90 @@
+require 'metaheuristics/metaheuristic_init_factory'
+
+class GenomeValues
+
+	attr_reader :values
+
+	# randomly generate a new random genome with +size+ components in the real range [-1.0, 1.0]
+	def self.new_random(size)
+		self.new(Array.new(size){ (rand - 0.5) * 2.0 })
+	end
+
+	# ctor
+	def initialize(values)
+		@values = values
+	end
+
+	# clone
+	def clone
+		self.new(values.clone)
+	end
+
+	# mutate this genome, return self
+	def mutate!(mutation_rate)
+		@values.size.times do |i|
+			@values[i] += (rand - 0.5) * 0.05 if rand < mutation_rate
+		end
+
+		self
+	end
+
+	# crossover this genome with another one, and return the resulting offspring
+	def crossover(genome)
+		self_values = @values
+		other_values = genome.values
+
+		values =
+			Array.new(self_values.size) do |i|
+				[self_values, other_values][rand(2)][i]
+			end
+
+		GenomeValues.new(values)
+	end
+end # GenomeValues
+
+
+# lambda: generate a genome with 8 values randomly generated in the real range [-1.0, 1.0]
+genome_init = lambda do
+	GenomeValues.new_random(8)
+end
+
+search_definition = {
+	:name            => :tournament_selection,
+	:population_size => 100,
+	:tournament_size => 10,
+	:elitism         => 5,
+	:mutation_rate   => 0.2
+}
+
+search_init = MetaheuristicInitFactory.from_definition(search_definition)
+
+# an evaluator which returns a higher fitness for components with lower
+# distance to the origin point (i.e minimises the absolute value of the
+# components).
+evaluator_minimiser = lambda do |genome|
+	sum_of_squares = genome.values.collect{ |v| v * v }.inject(&:+)
+	fitness = 1.0 / (1.0 + sum_of_squares)
+
+	fitness
+end
+
+search = search_init.call(
+	:genome_init => genome_init,
+	:evaluator   => evaluator_minimiser)
+
+highest_fitness = 0.0
+
+while highest_fitness < 0.99999999995
+	search.run_once
+
+	results    = search.results
+	best_hash  = results.best
+	generation = results.generation
+
+	highest_fitness = best_hash[:fitness]
+	fitness_string = ('%.10f' % highest_fitness).rjust(10)
+	generation_string = generation.to_s.rjust(5)
+	values_string = best_hash[:solution].values.collect{ |v| ('%.6f' % v).rjust(9) }.join(', ')
+	puts "  generation #{generation_string}   fitness: #{fitness_string}   values: #{values_string}"
+end
+

data/lib/metaheuristics/genome_search/alps_ga.rb

@@ -0,0 +1,229 @@
+require 'metaheuristics/metaheuristic_interface'
+require 'metaheuristics/search_results'
+require 'utils/assert'
+
+class AlpsGa < MetaheuristicInterface
+
+	# From Hornby 2006 ALPS
+	DEFAULTS = {
+		:layer_size                  => 100,
+		:max_layer_count             => 10,
+		:tournament_size             => 7,
+		:age_gap                     => 10,
+		:aging_scheme                => :polynomial,
+		:layer_elitism               => 3,
+		:overall_elitism             => 0,
+		:parents_from_previous_layer => true
+	}
+
+	attr_reader :results
+
+	class Individual
+		include Comparable
+
+		attr_reader :age, :solution, :fitness
+
+		# ctor
+		def initialize(solution, age = 0)
+			@solution = solution
+			@age      = age
+			@used     = false
+			@fitness  = nil
+		end
+
+		# tag as used 
+		def tag_as_used
+			@used = true
+		end
+
+		# age
+		def age!
+			if @used
+				@used = false
+				@age += 1
+			end
+		end
+
+		# evaluate, return fitness
+		def evaluate(evaluator)
+			@fitness = evaluator.call(solution)
+		end
+
+		# <=>
+		def <=>(individual)
+			self.fitness <=> individual.fitness
+		end
+	end # Individual
+
+	# ctor
+	def initialize(options)
+		@layer_size                  = options[:layer_size                 ] || DEFAULTS[:layer_size                 ]
+		@max_layer_count             = options[:max_layer_count            ] || DEFAULTS[:max_layer_count            ]
+		@tournament_size             = options[:tournament_size            ] || DEFAULTS[:tournament_size            ]
+		@age_gap                     = options[:age_gap                    ] || DEFAULTS[:age_gap                    ]
+		@aging_scheme                = options[:aging_scheme               ] || DEFAULTS[:aging_scheme               ]
+		@layer_elitism               = options[:layer_elitism              ] || DEFAULTS[:layer_elitism              ]
+		@overall_elitism             = options[:overall_elitism            ] || DEFAULTS[:overall_elitism            ]
+		@parents_from_previous_layer = options[:parents_from_previous_layer] || DEFAULTS[:parents_from_previous_layer]
+
+		@evaluator       = options[:evaluator      ] || (raise ArgumentError)
+		@mutation_rate   = options[:mutation_rate  ] || (raise ArgumentError)
+		@genome_init     = options[:genome_init    ] || (raise ArgumentError)
+
+		raise ArgumentError unless [:linear, :fibonacci, :polynomial, :exponential].include?(@aging_scheme)
+
+		@results = SearchResults.new
+		@layers  = []
+	end
+
+	# run once
+	def run_once
+		generation = @results.generation
+		if generation == 0
+			@layers[0] = Array.new(@layer_size){ Individual.new(@genome_init.call) }
+			evaluate_layer(0)
+		else
+			# all but bottom layer
+			(@layers.size - 1).downto(1) do |i|
+				generate_new_population_layer(i)
+				evaluate_layer(i)
+			end
+
+			# bottom layer
+			if generation % @age_gap == 0
+				move_to_layer(@layers[0], 1)
+				@layers[0] = Array.new(@layer_size){ Individual.new(@genome_init.call) }
+			else
+				generate_new_population_layer(0)
+			end
+			evaluate_layer(0)
+		end
+
+		# age population
+		@layers.each do |l|
+			l.each do |individual|
+				individual.age!
+			end
+		end
+
+		# promote individuals
+		promote_individuals
+
+		@results.increment_generation
+
+		@layers.each.with_index do |l, idx|
+			l.sort!.reverse!
+			$stderr << "= layer #{idx} : max age #{max_layer_age(idx)} ---------------------------------------------------------------\n"
+			l.each do |i|
+				$stderr << " - #{i.solution.__id__.to_s.rjust(7)}, fitness #{i.fitness.to_i.to_s.rjust(6)}, age #{i.age.to_s.rjust(4)}\n"
+			end
+		end
+		$stderr << "\n"
+	end
+
+private
+
+	# max age for layer +n+
+	def max_layer_age(n)
+		case(@aging_scheme)
+		when :linear     ; n + 1
+		when :fibonacci  ; fibonacci(n + 1)
+		when :polynomial ; n < 2 ? n + 1 : n ** 2
+		when :exponential; 2 ** n
+		else raise ArgumentError
+		end * @age_gap
+	end
+
+	# fibonacci
+	def fibonacci(n)
+		if n == 0 || n == 1
+			1
+		else
+			fibonacci(n - 1) + fibonacci(n - 2)
+		end
+	end
+
+	# evaluate layer
+	def evaluate_layer(n)
+		@layers[n].each do |individual|
+			fitness = individual.evaluate(@evaluator)
+			@results.add_solution(individual.solution, fitness)
+		end
+	end
+
+	# generate new population layer
+	def generate_new_population_layer(n)
+		current_layer = @layers[n]
+
+		parent_population = ((n == 0 || !@parents_from_previous_layer) ? current_layer : (@layers[n - 1] + current_layer)).sort
+
+		new_population = []
+
+		# elitism
+		elitism = @layer_elitism
+		elitism = @overall_elitism if n == (@layers.size - 1) && @overall_elitism > elitism
+
+		if elitism > 0
+			current_layer.sort.reverse[0, [elitism, current_layer.size].min].each do |i|
+				new_population << i
+			end
+		end
+
+		(@layer_size - new_population.size).times do
+			parent1_index = Array.new(@tournament_size){ rand(parent_population.size) }.max
+			parent2_index = Array.new(@tournament_size){ rand(parent_population.size) }.reject{ |v| v == parent1_index }.max
+			while parent2_index == nil || parent2_index == parent1_index
+				parent2_index = rand(parent_population.size)
+			end
+
+			parent1 = parent_population[parent1_index]
+			parent2 = parent_population[parent2_index]
+			
+			parent1.tag_as_used
+			parent2.tag_as_used
+			new_solution = parent1.solution.crossover(parent2.solution).mutate!(@mutation_rate)
+			new_population << Individual.new(new_solution, [parent1.age, parent2.age].max + 1)
+		end
+
+		@layers[n] = new_population
+	end
+
+	# promote individuals
+	def promote_individuals
+		layer_count = @layers.size
+
+		((layer_count == @max_layer_count) ? (layer_count - 2) : (layer_count -  1)).downto(0) do |n|
+			layer = @layers[n]
+			# take old ones from current layer
+			max_age = max_layer_age(n)
+			oldies = layer.select{ |i| i.age >= max_age }
+			if !oldies.empty?
+				layer.delete_if{     |i| i.age >= max_age }
+				move_to_layer(oldies, n + 1) # try to fit them in with the layer above
+			end
+		end
+	end
+
+	# try to fit individual within layer
+	def move_to_layer(individuals, n)
+		# add layer
+		if n > (@layers.size - 1)
+			assert{ n <  @max_layer_count }
+			assert{ n == @layers.size     }
+			@layers[n] = []
+		end
+
+		# add oldies in layer
+		a = (@layers[n] + individuals).sort do |a, b|
+			cmp_fitness = a.fitness <=> b.fitness
+			if cmp_fitness == 0
+				a.age <=> b.age
+			else
+				cmp_fitness
+			end
+		end.reverse
+
+		@layers[n] = a[0, [a.size, @layer_size].min]
+	end
+end # AlpsGa
+

data/lib/metaheuristics/genome_search/fgrn_ga.rb

@@ -0,0 +1,86 @@
+require 'metaheuristics/metaheuristic_interface'
+require 'metaheuristics/individual_solution'
+
+class FgrnGa < MetaheuristicInterface
+
+	DEFAULTS = {
+		:age_max             => 10,
+		:children_count      => 80,
+		:parents_coeff       => 0.4,
+		:population_size     => 100,
+		:random_parent_coeff => 0.01
+	}
+
+	attr_reader :results, :population
+
+	# ctor
+	def initialize(options)
+		@children_count         = options[:children_count        ] || DEFAULTS[:children_count     ]
+		@parents_coeff          = options[:parents_coeff         ] || DEFAULTS[:parents_coeff      ]
+		@population_size        = options[:population_size       ] || DEFAULTS[:population_size    ]
+		@random_parent_coeff    = options[:random_parent_coeff   ] || DEFAULTS[:random_parent_coeff]
+		@age_max                = options[:age_max               ] || DEFAULTS[:age_max            ]
+		@evaluate_children_only = options[:evaluate_children_only] || false
+		@evaluator              = options[:evaluator             ] || (raise ArgumentError)
+		@mutation_rate          = options[:mutation_rate         ] || (raise ArgumentError)
+
+		genome_init = options[:genome_init] || (raise ArgumentError)
+		@initial_genomes = Array.new(@population_size){ genome_init.call }
+
+		@results = SearchResults.new
+	end
+
+	# run once
+	def run_once
+		if @initial_genomes
+			@population = @initial_genomes.collect{ |genome| IndividualSolution.new(genome, @evaluator, @results) }
+			@initial_genomes = nil
+		else
+			# generate children
+			children =
+				Array.new(@children_count) do
+					parent1 = pick_parent
+					parent2 = pick_parent
+
+					genome = (parent1.crossover(parent2)).mutate!(@mutation_rate)
+					IndividualSolution.new(genome, @evaluator, @results)
+				end
+
+			@population.each{    |individual| individual.increment_age   } # increment age
+			@population.reject!{ |individual| individual.age >= @age_max } # reject too old
+
+			# carry over the best
+			carried_over_count = @population_size - @children_count
+			carried_over = @population[0, [carried_over_count, @population.size].min]
+
+			# re-evaluate carried over
+			if !@evaluate_children_only
+				carried_over.each do |individual|
+					individual.reevaluate
+				end
+			end
+
+			# merge carried over and children
+			@population = carried_over + children
+		end
+
+		@population.sort!.reverse!
+		@results.increment_generation
+
+		# debug: print population
+		@population.each do |i|
+			$stderr << "#{('%d' % i.fitness).rjust(5)} - #{i.__id__.to_s.rjust(10)} - age #{'X' * i.age}\n"
+		end
+	end # run_once
+
+private
+	# pick parent
+	def pick_parent
+		index = 
+			rand < @random_parent_coeff ?
+				rand(@population.size) :                                                # pick a parent at random
+				rand([(@parents_coeff * @population_size).round, @population.size].min) # pick a parent amongst the best individuals
+		@population[index].solution
+	end
+end # FgrnGa
+

data/lib/metaheuristics/genome_search/tournament_selection.rb

@@ -0,0 +1,77 @@
+require 'metaheuristics/metaheuristic_interface'
+require 'metaheuristics/individual_solution'
+require 'metaheuristics/search_results'
+
+class TournamentSelection < MetaheuristicInterface
+
+	DEFAULTS = {
+		:population_size => 100,
+		:tournament_size => 4,
+		:elitism         => 0
+	}
+
+	attr_reader :results
+
+	# ctor
+	def initialize(options)
+		@population_size = options[:population_size] || DEFAULTS[:population_size]
+		@tournament_size = options[:tournament_size] || DEFAULTS[:tournament_size]
+		@elitism         = options[:elitism        ] || DEFAULTS[:elitism        ]
+		@evaluator       = options[:evaluator      ] || (raise ArgumentError)
+		@mutation_rate   = options[:mutation_rate  ] || (raise ArgumentError)
+
+		# population
+		genome_init = options[:genome_init] || (raise ArgumentError)
+		@initial_genomes = Array.new(@population_size){ genome_init.call }
+		@population = nil
+
+		# results
+		@results = SearchResults.new
+	end
+
+	# run once
+	def run_once
+
+		# genomes
+		genomes =
+			if @initial_genomes # use initial genomes
+				ig = @initial_genomes
+				@initial_genomes = nil
+				ig
+			else # not initial run: generate new genomes
+				array = Array.new(@population_size)
+
+				# elitism
+				@elitism.times do |i|
+					array[i] = @population[i].solution
+				end
+
+				# generate children
+				(@population_size - @elitism).times do |i|
+					parent1 = pick_parent
+					parent2 = pick_parent
+
+					array[@elitism + i] = parent1.crossover(parent2).mutate!(@mutation_rate)
+				end
+
+				array
+			end
+
+		# evaluate genomes into the population
+		@population = genomes.collect do |genome|
+ 		 	IndividualSolution.new(genome, @evaluator, @results)
+		end
+
+		@population.sort!.reverse!
+		@results.increment_generation
+
+		self
+	end # run_once
+
+private
+	# pick parent
+	def pick_parent
+		@population.sample(@tournament_size).max.solution
+	end
+end # TournamentSelection
+

data/lib/metaheuristics/individual_solution.rb

@@ -0,0 +1,42 @@
+
+class IndividualSolution
+	include Comparable
+
+	attr_reader \
+		:age,
+		:solution,
+		:fitness
+
+	# ctor
+	def initialize(solution, evaluator, results)
+		@solution  = solution
+		@evaluator = evaluator
+		@results   = results
+		@age       = 0
+		evaluate
+	end
+
+	# increment age
+	def increment_age
+		@age += 1
+	end
+
+	# re-evaluate fitness
+	def reevaluate
+		raise RuntimeError if @fitness.nil?
+		evaluate
+	end
+
+	# <=>
+	def <=>(es)
+		@fitness <=> es.fitness
+	end
+
+private
+	# evaluate
+	def evaluate
+		@fitness = @evaluator.call(@solution)
+		@results.add_solution(@solution, @fitness)
+	end
+end # IndividualSolution
+

data/lib/metaheuristics/metaheuristic_init_factory.rb

@@ -0,0 +1,79 @@
+require 'metaheuristics/genome_search/alps_ga'
+require 'metaheuristics/genome_search/fgrn_ga'
+require 'metaheuristics/genome_search/tournament_selection'
+
+class MetaheuristicInitFactory
+
+	# from definition
+	def self.from_definition(definition)
+		name = definition[:name]
+		case(name)
+
+		# alps
+		when :alps
+			args = {
+				:layer_size      => definition[:layer_size     ],
+				:max_layer_count => definition[:max_layer_count],
+				:tournament_size => definition[:tournament_size],
+				:age_gap         => definition[:age_gap        ],
+				:aging_scheme    => definition[:aging_scheme   ],
+				:layer_elitism   => definition[:layer_elitism  ],
+				:overall_elitism => definition[:overall_elitism],
+				:mutation_rate   => definition[:mutation_rate  ] || (raise ArgumentError)
+			}
+
+			# init block
+			lambda do |options|
+				genome_init = options[:genome_init] || (raise ArgumentError)
+				evaluator   = options[:evaluator]   || (raise ArgumentError)
+
+				AlpsGa.new(args.merge(
+					:genome_init => genome_init,
+					:evaluator   => evaluator))
+			end
+
+		# fga
+		when :fga
+			args = {
+				:population_size        => definition[:population_size       ] || (raise ArgumentError),
+				:children_count         => definition[:children_count        ] || (raise ArgumentError),
+				:mutation_rate          => definition[:mutation_rate         ] || (raise ArgumentError),
+				:parents_coeff          => definition[:parents_coeff         ] || (raise ArgumentError),
+				:random_parent_coeff    => definition[:random_parent_coeff   ] || (raise ArgumentError),
+				:age_max                => definition[:age_max               ] || (raise ArgumentError),
+				:evaluate_children_only => definition[:evaluate_children_only] || false
+			}
+
+			# init block
+			lambda do |options|
+				genome_init = options[:genome_init] || (raise ArgumentError)
+				evaluator   = options[:evaluator]   || (raise ArgumentError)
+
+				FgrnGa.new(args.merge(
+					:genome_init => genome_init,
+					:evaluator   => evaluator))
+			end
+
+		# tournament selection
+		when :tournament_selection
+			args = {
+				:mutation_rate   => definition[:mutation_rate  ] || (raise ArgumentError),
+				:population_size => definition[:population_size],
+				:elitism         => definition[:elitism        ],
+				:tournament_size => definition[:tournament_size]
+			}
+
+			# init block
+			lambda do |options|
+				genome_init = options[:genome_init] || (raise ArgumentError)
+				evaluator   = options[:evaluator]   || (raise ArgumentError)
+
+				TournamentSelection.new(args.merge(
+					:genome_init => genome_init,
+					:evaluator   => evaluator))
+			end
+
+		else raise ArgumentError, name end
+	end # from_definition
+end # MetaheuristicInitFactory
+

data/lib/metaheuristics/metaheuristic_interface.rb

@@ -0,0 +1,13 @@
+
+# The interface to be implemented by metaheuristics algorithms.
+class MetaheuristicInterface
+
+	# Should return a +SearchResult+ object (or an object with the same interface
+	# as +SearchResult+)
+	def results ; raise NotImplementedError; end
+	
+	# Run one search iteration, this should include the evaluation of the fitness
+	# of one or more individuals (e.g. a population generation for a GA)
+	def run_once; raise NotImplementedError; end
+end # MetaheuristicInterface
+

data/lib/metaheuristics/search_results.rb

@@ -0,0 +1,44 @@
+
+
+class SearchResults
+
+	attr_reader \
+		:generation,
+		:evaluation,
+		:best        # hash containing the keys : fitness, solution, evaluation, generation
+
+	# ctor
+	def initialize
+		@generation = 0
+		@evaluation = 0
+		@best       = nil
+	end
+
+	# increment generation
+	def increment_generation
+		@generation += 1
+	end
+
+	# add solution
+	def add_solution(solution, fitness)
+		@evaluation += 1
+		if @best.nil? || fitness > @best[:fitness]
+			@best = {
+				:fitness    => fitness,
+				:solution   => solution,
+				:evaluation => @evaluation,
+				:generation => @generation
+			}
+		end
+	end
+
+	# to hash
+	def to_hash
+		{
+			:generation => @generation,
+			:evaluation => @evaluation,
+			:best       => @best.clone
+		}
+	end
+end # SearchResults
+

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: metaheuristics
+version: !ruby/object:Gem::Version
+  prerelease:
+  version: 0.1.0
+platform: ruby
+authors:
+- Jean Krohn
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2012-08-29 00:00:00.000000000 Z
+dependencies: []
+description: Metaheuristics include Genetic Algorithms (GAs), such as ALPS and tournament selection.
+email: jbk@susano.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/metaheuristics/individual_solution.rb
+- lib/metaheuristics/search_results.rb
+- lib/metaheuristics/metaheuristic_interface.rb
+- lib/metaheuristics/metaheuristic_init_factory.rb
+- lib/metaheuristics/genome_search/alps_ga.rb
+- lib/metaheuristics/genome_search/fgrn_ga.rb
+- lib/metaheuristics/genome_search/tournament_selection.rb
+- examples/example_minimiser.rb
+homepage: http://github.com/susano/metaheuristics
+licenses: []
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: !binary |-
+        MA==
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: !binary |-
+        MA==
+  none: false
+requirements: []
+rubyforge_project:
+rubygems_version: 1.8.24
+signing_key:
+specification_version: 3
+summary: Metaheuristic search/optimisation algorithms.
+test_files: []