evosynth 0.1.0

data/examples/hacking.rb

@@ -0,0 +1,62 @@
+#	Copyright (c) 2009, 2010 Yves Adler <yves.adler@googlemail.com>
+#
+#	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.
+
+
+require 'evosynth'
+#require 'profile'
+
+
+module Examples
+	# lets find a solution for http://www.danielgrunwald.de/coding/hacking/2936.php
+	module Hacking
+
+		GENOME_SIZE = 7
+		ALPHABET = "abcdefghijklmnopqrstuvwxyz"
+
+		class HackingEvaluator < EvoSynth::Evaluator
+
+			def calculate_fitness(individual)
+				suma = 0.0
+
+				individual.genome.each do |gene|
+					suma *= 26
+					suma += ALPHABET.index(gene) + 1
+				end
+
+				(6030912063.0 - suma).abs
+			end
+		end
+
+		FLIP_CHAR = lambda { ALPHABET[EvoSynth.rand(ALPHABET.size)] }
+
+		profile = EvoSynth::Profile.new(
+			:individual			=> EvoSynth::MinimizingIndividual.new( EvoSynth::ArrayGenome.new(GENOME_SIZE) { ALPHABET[EvoSynth.rand(ALPHABET.size)] }),
+			:evaluator			=> Hacking::HackingEvaluator.new,
+			:mutation			=> EvoSynth::Mutations::BinaryMutation.new(FLIP_CHAR)
+		)
+
+		evolver = EvoSynth::Evolvers::Hillclimber.new(profile)
+		evolver.run_until_fitness_reached(0.0)
+		puts "found passwort ('#{evolver.individual.genome.join("")}') after #{evolver.generations_computed} generations..."
+	end
+end

data/examples/local_search.rb

@@ -0,0 +1,109 @@
+#	Copyright (c) 2009, 2010 Yves Adler <yves.adler@googlemail.com>
+#
+#	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.
+
+
+require 'evosynth'
+#require 'profile'
+
+
+module Examples
+	module LocalSearch
+
+		VALUE_BITS = 16
+		DIMENSIONS = 5
+		GENERATIONS = 5000
+		GENOME_SIZE = VALUE_BITS * DIMENSIONS
+		UPPER_LIMIT = 5.12
+		LOWER_LIMIT = -5.12
+
+		class LocalSearchEvaluator < EvoSynth::Evaluator
+
+			def decode(individual)
+				values = []
+				DIMENSIONS.times do |dim|
+					values << EvoSynth::Decoder.binary_to_real(individual.genome[dim * VALUE_BITS, VALUE_BITS], LOWER_LIMIT, UPPER_LIMIT)
+				end
+				values
+			end
+
+			def calculate_fitness(individual)
+				EvoSynth::Problems::FloatBenchmarkFuntions.sphere(decode(individual))
+			end
+		end
+
+		def LocalSearch.create_individual
+			EvoSynth::MinimizingIndividual.new( EvoSynth::ArrayGenome.new(GENOME_SIZE) { EvoSynth.rand_bool } )
+		end
+
+		def LocalSearch.print_acceptance_state(evolver)
+			puts "\nAcceptance:" unless evolver.acceptance.instance_variables.empty?
+			evolver.acceptance.instance_variables.each do |var|
+				is_accessor = (var.to_s.gsub("@", "") + "=").to_sym
+				puts "\t#{var} = #{evolver.acceptance.instance_variable_get(var)}" if evolver.acceptance.respond_to?(is_accessor)
+			end
+			puts
+		end
+
+		def LocalSearch.run_with(profile, individual)
+			puts "--- Local Search with #{profile.acceptance.to_s} ---\n"
+
+			profile.individual = individual.deep_clone
+			evolver = EvoSynth::Evolvers::LocalSearch.new(profile)
+			LocalSearch.print_acceptance_state(evolver)
+
+			evolver.add_observer(EvoSynth::Output.create_console_logger(500,
+				"generations" => ->{ evolver.generations_computed },
+				"fitness"     => ->{ evolver.best_solution.fitness },
+				"temperature" => ->{ evolver.acceptance.temperature },
+				"alpha"       => ->{ evolver.acceptance.alpha },
+				"delta"       => ->{ evolver.acceptance.delta }
+			))
+
+			result = evolver.run_until_generations_reached(GENERATIONS)
+			LocalSearch.print_acceptance_state(evolver)
+
+			puts "\n-> fitness after #{GENERATIONS} generations: #{profile.evaluator.calculate_fitness(result)}\n\n"
+		end
+
+		profile = EvoSynth::Profile.new(
+			:mutation			=> EvoSynth::Mutations::BinaryMutation.new(EvoSynth::Mutations::Functions::FLIP_BOOLEAN),
+			:evaluator			=> LocalSearchEvaluator.new
+		)
+		individual = LocalSearch.create_individual
+
+		profile.acceptance = EvoSynth::Evolvers::LocalSearch::HillclimberAcceptance.new
+		LocalSearch.run_with(profile, individual)
+
+		profile.acceptance = EvoSynth::Evolvers::LocalSearch::SimulatedAnnealingAcceptance.new(5000.0)
+		LocalSearch.run_with(profile, individual)
+
+		profile.acceptance = EvoSynth::Evolvers::LocalSearch::ThresholdAcceptance.new(5000.0)
+		LocalSearch.run_with(profile, individual)
+
+		profile.acceptance = EvoSynth::Evolvers::LocalSearch::GreatDelugeAcceptance.new(2500.0)
+		LocalSearch.run_with(profile, individual)
+
+		profile.acceptance = EvoSynth::Evolvers::LocalSearch::RecordToRecordTravelAcceptance.new(5000.0)
+		LocalSearch.run_with(profile, individual)
+	end
+end

data/examples/max_ones.rb

@@ -0,0 +1,83 @@
+#	Copyright (c) 2009, 2010 Yves Adler <yves.adler@googlemail.com>
+#
+#	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.
+
+
+require 'evosynth'
+#require 'profile'
+
+module Examples
+	module MaxOnes
+
+		GENOME_SIZE = 50
+		POP_SIZE = 25
+		MAX_EVALUATIONS = 5000
+
+		# this is just for the sake of demonstration stuff - you could also use
+		# EvoSynth::Problems::BinaryBenchmarkFuntions.count_ones()
+
+		class MaxOnesEvaluator < EvoSynth::Evaluator
+			def calculate_fitness(individual)
+				individual.genome.inject(0.0) { |fitness, gene| fitness += gene ? 1 : 0 }
+			end
+		end
+
+		def MaxOnes.create_individual
+			EvoSynth::MaximizingIndividual.new( EvoSynth::ArrayGenome.new(GENOME_SIZE) { EvoSynth.rand_bool } )
+		end
+
+		profile = EvoSynth::Profile.new(
+			:individual			=> MaxOnes.create_individual,
+			:population			=> EvoSynth::Population.new(POP_SIZE) { MaxOnes.create_individual },
+			:evaluator			=> MaxOnes::MaxOnesEvaluator.new,
+			:mutation			=> EvoSynth::Mutations::BinaryMutation.new(EvoSynth::Mutations::Functions::FLIP_BOOLEAN)
+		)
+
+		# ---------------------------- Use simple Hillclimber ---------------------------- #
+
+		evolver = EvoSynth::Evolvers::Hillclimber.new(profile)
+		evolver.add_observer(EvoSynth::Output.create_console_logger(500,
+			"generations"	=> ->{ evolver.generations_computed },
+			"bestfitness"   => ->{ evolver.best_solution.fitness },
+			"worstfitness"  => ->{ evolver.worst_solution.fitness }
+		))
+
+		puts "\nRunning Hillclimber...\n"
+		result = evolver.run_until { profile.evaluator.called < MAX_EVALUATIONS }
+		puts "\nIndividual after evolution:  #{profile.individual}"
+
+		# --------------------------- Use GA with weak elistism --------------------------- #
+
+		profile.evaluator.reset_counters
+		evolver = EvoSynth::Evolvers::GeneticAlgorithm.new(profile)
+		EvoSynth::Evolvers.add_weak_elistism(evolver)
+		evolver.add_observer(EvoSynth::Output.create_console_logger(50,
+			"generations"	=> ->{ evolver.generations_computed },
+			"bestfitness"   => ->{ evolver.best_solution.fitness },
+			"worstfitness"  => ->{ evolver.worst_solution.fitness }
+		))
+
+		puts "\nRunning Genetic Algorithm with elitism...\n"
+		result = evolver.run_until { profile.evaluator.called < MAX_EVALUATIONS }
+		puts "\nBest Individual after evolution:  #{result.best}"
+	end
+end

data/examples/partition.rb

@@ -0,0 +1,172 @@
+#	Copyright (c) 2009, 2010 Yves Adler <yves.adler@googlemail.com>
+#
+#	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.
+
+
+require 'set'
+require 'evosynth'
+
+
+module Examples
+	module Partitionproblem
+
+		class PartitionEvaluator < EvoSynth::Evaluator
+			def calculate_fitness(individual)
+				sum_a = individual.partition_a.inject(0) { |sum, n| sum + n }
+				sum_b = individual.partition_b.inject(0) { |sum, n| sum + n }
+				(sum_a - sum_b).abs
+			end
+		end
+
+		# We've to carefully overwrite functions here, because we actually have 2 genomes
+
+		class PartitionIndividual < EvoSynth::MinimizingIndividual
+
+			attr_accessor :partition_a, :partition_b
+
+			def initialize(partition_a, partition_b)
+				@partition_a = partition_a;
+				@partition_b = partition_b;
+				@fitness = Float::MAX
+			end
+
+			def fitness=(value)
+				@fitness = value
+				@partition_a.changed = false
+				@partition_b.changed = false
+			end
+
+			def deep_clone
+				my_clone = self.clone
+				my_clone.partition_a = Marshal.load( Marshal.dump( self.partition_a ) )
+				my_clone.partition_b = Marshal.load( Marshal.dump( self.partition_b ) )
+				my_clone
+			end
+
+			def changed?
+				@partition_a.changed? || @partition_b.changed?
+			end
+
+			def to_s
+				"partition individual <fitness = #{fitness}, partition_a.size = #{@partition_a.size}, partition_b.size = #{@partition_b.size}>"
+			end
+
+		end
+
+		class PartitionMutation
+
+			def mutate(individual)
+				mutated = individual.deep_clone
+				part_a, part_b = mutated.partition_a, mutated.partition_b
+
+				if EvoSynth.rand_bool
+					part_a << part_b.delete_at(EvoSynth.rand(part_b.size)) unless mutated.partition_b.empty?
+				else
+					part_b << part_a.delete_at(EvoSynth.rand(part_a.size)) unless mutated.partition_a.empty?
+				end
+
+				mutated
+			end
+
+			def to_s
+				"custom made mutation for the partition problem"
+			end
+
+		end
+
+
+		# these are just Testdata generators
+
+		module Testdata
+
+			def Testdata.gen_tiny_set
+				problem = Array.new(25)
+				problem.fill { |i| i }
+			end
+
+			def Testdata.gen_layer_set
+				problem = Set.new
+				problem.add(EvoSynth.rand(1000) * EvoSynth.rand(1000)) while problem.size < 200
+				problem.add(EvoSynth.rand(1000)) while problem.size < 1000
+				problem.to_a
+			end
+
+			def Testdata.gen_standard_set
+				problem = Array.new
+				1000.times { |i| problem.insert(-1, i)  }
+				problem
+			end
+
+			def Testdata.gen_random_set
+				problem = Set.new
+				problem.add(EvoSynth.rand(1000000)) while problem.size < 1000
+				problem.to_a
+			end
+
+			def Testdata.gen_big_set
+				problem = Set.new
+				problem.add(EvoSynth.rand(10000) * 100) while problem.size < 1000
+				problem.to_a
+			end
+		end
+
+		# creates a new (random) individual from a given problem
+
+		def Partitionproblem.get_new_individual_from(problem)
+			border = EvoSynth.rand(problem.size)
+			part_a, part_b = EvoSynth::ArrayGenome.new, EvoSynth::ArrayGenome.new
+
+			problem.size.times do
+				|index| index < border ? part_a << problem[index] : part_b << problem[index]
+			end
+
+			Partitionproblem::PartitionIndividual.new(part_a, part_b)
+		end
+
+		POPULATION_SIZE = 20
+		GENERATIONS = 500
+		GOAL = 0.0
+
+		problem = Partitionproblem::Testdata.gen_layer_set
+		base_population = EvoSynth::Population.new(POPULATION_SIZE) { Partitionproblem.get_new_individual_from(problem) }
+
+		profile = EvoSynth::Profile.new(
+			:mutation			=> PartitionMutation.new,
+			:parent_selection	=> EvoSynth::Selections::TournamentSelection.new(3),
+			:recombination		=> EvoSynth::Recombinations::Identity.new,
+			:evaluator			=> Partitionproblem::PartitionEvaluator.new
+		)
+
+		profile.population = base_population.deep_clone
+		puts "running MemeticAlgorithm with elitism..."
+		evolver = EvoSynth::Evolvers::MemeticAlgorithm.new(profile)
+		EvoSynth::Evolvers.add_weak_elistism(evolver)
+		evolver.add_observer(EvoSynth::Output.create_console_logger(25,
+			"generations" => ->{ evolver.generations_computed },
+			"fitness"     => ->{ evolver.best_solution.fitness },
+			"best"		  => ->{ evolver.best_solution.to_s }
+		))
+
+		evolver.run_until { |gen, best| best.fitness <= GOAL || gen >= GENERATIONS }
+		puts "\nResult after #{evolver.generations_computed} generations: #{evolver.best_solution}"
+	end
+end

data/examples/spk.rb

@@ -0,0 +1,106 @@
+#	Copyright (c) 2009, 2010 Yves Adler <yves.adler@googlemail.com>
+#
+#	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.
+
+
+require 'evosynth'
+
+
+# TODO: this could be a benchmark problem
+
+module Examples
+	module SPk
+
+		class SPkFitnessEvaluator < EvoSynth::Evaluator
+
+			def initialize(k)
+				@k = k
+				super()
+			end
+
+			def calculate_fitness(individual)
+				fitness = 0.0
+
+				ones = individual.genome.inject(0) do |ones, gene|
+					ones += gene ? 1 : 0
+				end
+
+				if is_valid(individual.genome)
+					fitness = individual.genome.size * (ones + 1)
+				else
+					fitness = individual.genome.size - ones
+				end
+
+				fitness
+			end
+
+			def is_valid(genome)
+				valid = false
+
+				len_of_ones = calc_length_of_ones(genome)
+				max_k = (genome.size.to_f / (3.0 * @k*@k).to_f).ceil
+				valid = true if !len_of_ones.nil? && len_of_ones / @k <= max_k && len_of_ones % @k == 0
+
+				valid
+			end
+
+			def calc_length_of_ones(genome)
+				count, len_of_ones = 0, 0
+				end_of_ones, end_of_zeros = false, false
+
+				genome.each do |gene|
+					end_of_ones_reached = !gene && !end_of_ones
+					end_of_zeros_reached = gene && end_of_ones && !end_of_zeros
+
+					if end_of_ones_reached
+						len_of_ones = count
+						end_of_ones = true
+					elsif end_of_zeros_reached
+						end_of_zeros = true
+					end
+
+					count += 1
+				end
+
+				len_of_ones = count if !end_of_ones
+				len_of_ones = nil if end_of_zeros
+				len_of_ones
+			end
+
+		end
+ 
+		K = 2
+		GENOME_SIZE = 16
+		GENERATIONS = 5000
+
+		profile = EvoSynth::Profile.new(
+			:individual			=> EvoSynth::MaximizingIndividual.new( EvoSynth::ArrayGenome.new(GENOME_SIZE) { EvoSynth.rand_bool } ),
+			:mutation			=> EvoSynth::Mutations::BinaryMutation.new(EvoSynth::Mutations::Functions::FLIP_BOOLEAN),
+			:evaluator			=> SPkFitnessEvaluator.new(K)
+		)
+
+		evolver = EvoSynth::Evolvers::Hillclimber.new(profile)
+		puts "Running #{evolver}...\n\n"
+		result = evolver.run_until_generations_reached(GENERATIONS)
+		puts "result: #{result}"
+	end
+end