evosynth 0.1.0

data/lib/evosynth/operators/meta_operators/sequential_combined_operator.rb

@@ -0,0 +1,73 @@
+#	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.
+
+
+module EvoSynth
+	module MetaOperators
+
+		# This operator is a container for other operators. When SequentialCombinedOperator gets called with a method,
+		# that it does not implement, each operator has a probability to get called with that method. But in contrast to
+		# the ProportionalCombinedOperator all operators will get called. All Operators should be of the same kind, otherwise
+		# you will most likely receive a exception.
+		# 
+		# Most likely you will combine mutations and recombinations and therefore mutate() or recombine() will get called.
+
+		class SequentialCombinedOperator
+
+			def initialize(*ops)
+				@operators = []
+				ops.each { |operator| add(operator) }
+			end
+
+
+			# default probability is 1.0
+
+			def add(operator, probability = 1.0)
+				probability = 1.0 if probability > 1.0
+				@operators << [operator, probability]
+				self
+			end
+
+
+			def method_missing(method_name, *args)
+				raise "no operator to call" if @operators.empty?
+
+				result = args
+				@operators.each do |operator|
+					result = operator[0].send(method_name, *result) if EvoSynth.rand < operator[1]
+				end
+
+				result
+			end
+
+
+			def to_s
+				operators_to_s = []
+				@operators.each { |op| operators_to_s << "#{op[0].to_s} (probability: #{op[1]})" }
+				"sequential combinded operator <operators: #{operators_to_s.join(', ')}>"
+			end
+
+		end
+
+	end
+end

data/lib/evosynth/operators/mutations.rb

@@ -0,0 +1,47 @@
+#	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.
+
+
+module EvoSynth
+
+	# All mutations of EvoSynth should be inside this Module. The given individual has to provide a <i>deep_clone</i> method,
+	# which clones the individual and its genome.
+	#
+	# No mutation should change the given individual.
+
+	module Mutations
+	end
+end
+
+require 'evosynth/operators/mutations/flip_functions'
+require 'evosynth/operators/mutations/one_gene_flipping'
+require 'evosynth/operators/mutations/binary_mutation'
+require 'evosynth/operators/mutations/efficient_binary_mutation'
+require 'evosynth/operators/mutations/identity'
+require 'evosynth/operators/mutations/shifting_mutation'
+require 'evosynth/operators/mutations/mixing_mutation'
+require 'evosynth/operators/mutations/exchange_mutation'
+require 'evosynth/operators/mutations/inversion_mutation'
+require 'evosynth/operators/mutations/gauss_mutation'
+require 'evosynth/operators/mutations/uniform_real_mutation'
+require 'evosynth/operators/mutations/self_adaptive_gauss_mutation'

data/lib/evosynth/operators/mutations/binary_mutation.rb

@@ -0,0 +1,100 @@
+#	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.
+
+
+module EvoSynth
+	module Mutations
+
+		# This mutations flips each gene in the genome of a given individual using the given flip function (a lambda) with a given
+		# probability and returns a mutated individual. To use this mutation the flip_function has to return the negation/inverse
+		# of a given gene. This mutations is based on BINAERE-MUTATION (Weicker 2007, page 59).
+
+		class BinaryMutation
+
+			# Each gene is flipped with this probability (should be between 0 and 1)
+
+			attr_accessor :probability
+
+			# This function (lambda) is used to flip each gene
+
+			attr_accessor :flip_function
+
+			# the default mutation probability
+
+			DEFAULT_PROBABILITY = 0.1
+
+			#	:call-seq:
+			#		BinaryMutation.new(Lambda) -> BinaryMutation
+			#		BinaryMutation.new(Lambda, Float) -> BinaryMutation (overrides default probability)
+			#
+			# Returns a new BinaryMutation. In the first form, the default mutation probability BinaryMutation::DEFAULT_PROBABILITY (0.1)
+			# is used. In the second it creates a BinaryMutation with the given probability.
+			#
+			#     custom_flip_function = lambda { |gene| EvoSynth.rand(42 * gene) }
+			#     BinaryMutation.new(custom_flip_function)
+			#     BinaryMutation.new(EvoSynth::Mutations::Functions::FLIP_BOOLEAN, 0.01)
+
+			def initialize(flip_function, probability = DEFAULT_PROBABILITY)
+				@flip_function = flip_function
+				@probability = probability
+			end
+
+			#	:call-seq:
+			#		mutate(Individual) -> Individual
+			#
+			# Returns the mutation (with the given flip function) of a given individual.
+			#
+			#     m = BinaryMutation.new
+			#     m.mutate(a_individual)   #=> a_new_individual
+
+			def mutate(individual)
+				mutated = individual.deep_clone
+				genome = mutated.genome
+
+				genome.size.times do |index|
+					if @flip_function.arity == 1
+						genome[index] = @flip_function.call(genome[index]) if EvoSynth.rand <= @probability
+					else
+						genome[index] = @flip_function.call if EvoSynth.rand <= @probability
+					end
+				end
+
+				mutated
+			end
+
+			#	:call-seq:
+			#		to_s -> string
+			#
+			# Returns description of this mutation
+			#
+			#     m = BinaryMutation.new(0.01)
+			#     m.to_s                   #=> "binary mutation <probability: 0.01>"
+
+			def to_s
+				"binary mutation <probability: #{@probability}>"
+			end
+
+		end
+
+	end
+end

data/lib/evosynth/operators/mutations/efficient_binary_mutation.rb

@@ -0,0 +1,105 @@
+#	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.
+
+
+module EvoSynth
+	module Mutations
+
+		# This mutation is basically a optimized version of the BinaryMutation and should have a better performance on long genomes.
+		#
+		# It flips each gene in the genome of a given individual using the given flip function (a lambda) with a given
+		# probability and returns a mutated individual. To use this mutation the flip_function has to return the negation/inverse
+		# of a given gene. This mutations is based on EFFIZIENTE-BINAERE-MUTATION (Weicker 2007, page 130).
+
+		class EfficientBinaryMutation
+
+			# Each gene is flipped with this probability (should be between 0 and 1)
+
+			attr_accessor :probability
+
+			# This function is used to flip each gene
+
+			attr_accessor :flip_function
+
+			# the default mutation probability
+
+			DEFAULT_PROBABILITY = 0.1
+
+			#	:call-seq:
+			#		EfficientBinaryMutation.new(Lambda) -> EfficientBinaryMutation
+			#		EfficientBinaryMutation.new(Lambda, Float) -> EfficientBinaryMutation (overrides default probability)
+			#
+			# Returns a new EfficientBinaryMutation. In the first form, the default mutation probability BinaryMutation::DEFAULT_PROBABILITY (0.1)
+			# is used. In the second it creates a BinaryMutation with the given probability.
+			#
+			#     custom_flip_function = lambda { |gene| EvoSynth.rand(42 * gene) }
+			#     EfficientBinaryMutation.new(custom_flip_function)
+			#     EfficientBinaryMutation.new(EvoSynth::Mutations::Functions::FLIP_BOOLEAN, 0.01)
+
+			def initialize(flip_function, probability = DEFAULT_PROBABILITY)
+				@flip_function = flip_function
+				@probability = probability
+			end
+
+			#	:call-seq:
+			#		mutate(Individual) -> Individual
+			#
+			# Returns the mutation (with the given flip function) of a given individual.
+			#
+			#     m = EfficientBinaryMutation.new
+			#     m.mutate(a_individual)   #=> a_new_individual
+
+			def mutate(individual)
+				mutated = individual.deep_clone
+				@next_index = EvoSynth.rand(mutated.genome.size) unless defined? @next_index
+
+				while @next_index < mutated.genome.size
+					if @flip_function.arity == 1
+						mutated.genome[@next_index] = @flip_function.call(mutated.genome[@next_index])
+					else
+						mutated.genome[@next_index] = @flip_function.call
+					end
+					
+					@next_index += (Math.log(EvoSynth.rand) / Math.log(1 - @probability)).ceil
+				end
+
+				@next_index -= mutated.genome.size
+				mutated
+			end
+
+			#	:call-seq:
+			#		to_s -> string
+			#
+			# Returns description of this mutation
+			#
+			#     m = EfficientBinaryMutation.new(0.91)
+			#     m.to_s                   #=> "efficient binary muation <probability: 0.01>"
+
+			def to_s
+				"efficient binary muation <probability: #{@probability}>"
+			end
+
+		end
+
+	end
+end

data/lib/evosynth/operators/mutations/exchange_mutation.rb

@@ -0,0 +1,107 @@
+#	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.
+
+
+module EvoSynth
+	module Mutations
+
+		# This mutations exchanges two genes in the genome of a given individual and returns a mutated individual.
+		# It is based on VERTAUSCHENDE-MUTATION (Weicker 2007, page 27) and DREIERTAUSCH-MUTATION (Weicker 2007, page 107)
+		#
+		# This mutations does not destroy permutations.
+		
+
+		class ExchangeMutation
+
+			# The number of genes that will be swapped during this mutation (default is 2).
+
+			attr_accessor :swap_count
+
+			DEFAULT_SWAP_COUNT = 2
+
+			#	:call-seq:
+			#		ExchangeMutation.new
+			#		ExchangeMutation(Fixnum) -> ExchangeMutation (overrides default swap count)
+			#
+			# Returns a new ExchangeMutation. In the first form, the default swap count is used.
+			# In the second it creates a ExchangeMutation with the given swap count.
+			#
+			#     ExchangeMutation.new
+			#     ExchangeMutation.new(3)
+
+			def initialize(swap_count = DEFAULT_SWAP_COUNT)
+				@swap_count = swap_count
+			end
+
+			#	:call-seq:
+			#		mutate(Individual) -> Individual
+			#
+			# Returns the mutation of a given individual.
+			#
+			#     m = ExchangeMutation.new
+			#     m.mutate(a_individual)   #=> a_new_individual
+
+			def mutate(individual)
+				mutated = individual.deep_clone
+				genome = mutated.genome
+
+				indexes = rand_indexes(genome.size)
+
+				(indexes.size - 1).times do |index|
+					index_one = indexes[index]
+					index_two = indexes[index + 1]
+					index_two = indexes[0] if index_two.nil?
+
+					genome[index_one], genome[index_two] = genome[index_two], genome[index_one]
+				end
+
+				mutated
+			end
+
+			#	:call-seq:
+			#		to_s -> string
+			#
+			# Returns description of this mutation
+			#
+			#     m = ExchangeMutation.new
+			#     m.to_s                   #=> "exchange mutation"
+
+			def to_s
+				"exchange mutation <swap count: #{@swap_count}>"
+			end
+
+			private
+
+			def rand_indexes(genome_size)
+				indexes = Set.new
+				@swap_count.times do
+					new_index = EvoSynth.rand(genome_size)
+					new_index = EvoSynth.rand(genome_size) while indexes.include?(new_index)
+					indexes << new_index
+				end
+				indexes.to_a
+			end
+		end
+
+	end
+end

data/lib/evosynth/operators/mutations/flip_functions.rb

@@ -0,0 +1,45 @@
+#	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.
+
+
+module EvoSynth
+	module Mutations
+
+		# Contains all predefined flip functions to be used with the BinaryMutation, EfficientBinaryMutation and
+		# OneGeneFlipping mutation.
+
+		module Functions
+
+			# inverts a boolean value
+			FLIP_BOOLEAN = lambda { |gene| !gene }
+
+			# inverts a integer in a boolean manner
+			FLIP_BINARY = lambda { |gene| gene == 0 ? 1 : 0 }
+
+			# negates a integer
+			FLIP_NEGATE_NUMBER = lambda { |gene| gene * -1 }
+
+		end
+
+	end
+end