algorithm-genetic 0.0.1

data/README.md

@@ -0,0 +1,29 @@
+# Algorithm::Genetic
+
+A Generic Algorithm Library for Ruby Language
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'algorithm-genetic'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install algorithm-genetic
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/tdtds/algorithm-genetic/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+

data/algorithm-genetic.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'algorithm/genetic/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "algorithm-genetic"
+  spec.version       = Algorithm::Genetic::VERSION
+  spec.authors       = ["TADA Tadashi"]
+  spec.email         = ["t@tdtds.jp"]
+  spec.summary       = %q{A Generic Algorithm Library for Ruby Language}
+  spec.description   = %q{A Generic Algorithm Library for Ruby Language}
+  spec.homepage      = ""
+  spec.license       = "GPL"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "pry"
+end

data/lib/algorithm/genetic.rb

@@ -0,0 +1,10 @@
+require "algorithm/genetic/version"
+require "algorithm/genetic/evaluator"
+require "algorithm/genetic/gene"
+require "algorithm/genetic/population"
+
+module Algorithm
+  module Genetic
+    # Your code goes here...
+  end
+end

data/lib/algorithm/genetic/crossover/order.rb

@@ -0,0 +1,22 @@
+#
+# Crossover::Order: order crossover
+#
+module Algorithm::Genetic::Crossover
+	module Order
+		def crossover(parent1, parent2)
+			cut_point = rand(parent1.code.length)
+			child1 = mate(parent1.code, parent2.code, cut_point)
+			child2 = mate(parent2.code, parent1.code, cut_point)
+			return child1, child2
+		end
+
+	private
+		def mate(p1, p2, point)
+			child = p1[0, point]
+			p2.each do |g|
+				child << g unless child.index(g)
+			end
+			return child
+		end
+	end
+end

data/lib/algorithm/genetic/crossover/point.rb

@@ -0,0 +1,13 @@
+#
+# Crossover::Point: (one) point crossover
+#
+module Algorithm::Genetic::Crossover
+	module Point
+		def crossover(parent1, parent2, cut_num)
+			pivot = (parent1.code.length / 2.0).round
+			child1 = parent1.code[0, pivot] + parent2.code[pivot, pivot]
+			child2 = parent2.code[0, pivot] + parent1.code[pivot, pivot]
+			return child1, child2
+		end
+	end
+end

data/lib/algorithm/genetic/evaluator.rb

@@ -0,0 +1,24 @@
+
+module Algorithm
+	module Genetic
+		#
+		# = evaluate fitness of a gene
+		#
+		class Evaluator
+			# evaluate fitness, implement by yourself
+			#
+			# gene :: a instance of Gene class
+			def fitness(gene)
+				raise NotImplementedError.new("implement 'fitness' method by yourself.")
+			end
+
+			# judgment of termination
+			#
+			# gene :: a instance of Gene class
+			def terminated?(gene)
+				raise NotImplementedError.new("implement 'terminated?' method by yourself.")
+			end
+		end
+	end
+end
+

data/lib/algorithm/genetic/gene.rb

@@ -0,0 +1,63 @@
+module Algorithm
+	module Genetic
+		#
+		# = A gene class
+		#
+		class Gene
+			attr_reader :code, :fitness
+
+			# constructor of Gene
+			#
+			# code :: initial code as Array
+			# evaluator :: a Evaluator instance or a Proc instance returns Evaluator instance
+			# opts :: hash of options
+			#
+			# options:
+			#   :crossover :: an array of module name including crossover method and params
+			#   :mutation  :: an array of module name including mutate method and params
+			#   :mutation_chance :: mutation chance (float of 0 to 1)
+			def initialize(code, evaluator, opts = {})
+				@code, @evaluator_org, @opts = code, evaluator, opts
+				if @evaluator_org.respond_to?(:fitness) # Evaluator instance
+					@evaluator = @evaluator_org
+				else # Proc instance
+					@evaluator = @evaluator_org.call
+				end
+				@fitness = @evaluator.fitness(self)
+
+				if opts[:crossover]
+					@crossover_params = opts[:crossover].dup
+					crossover_module = @crossover_params.shift.to_s.capitalize
+					self.extend(Algorithm::Genetic::Crossover.const_get(crossover_module))
+				end
+				if opts[:mutation]
+					@mutation_params = opts[:mutation].dup
+					mutation_module = @mutation_params.shift.to_s.capitalize
+					self.extend(Algorithm::Genetic::Mutation.const_get(mutation_module))
+				end
+				@mutation_chance = opts[:mutation_chance] || 0.5
+			end
+
+			# crossover with a partner, returning a couple of children
+			#
+			# partner :: a partner's gene
+			def crossover_with(partner)
+				code1, code2 = crossover(self, partner, *@crossover_params)
+				return Gene.new(code1, @evaluator_org, @opts), Gene.new(code2, @evaluator_org, @opts)
+			end
+
+			# mutate the code
+			def mutate!
+				return if rand > @mutation_chance
+				@code = mutate(@code, *@mutation_params)
+				@fitness = @evaluator.fitness(self)
+			end
+
+			# judgement termination
+			def terminated?
+				@evaluator.terminated?(self)
+			end
+		end
+	end
+end
+

data/lib/algorithm/genetic/mutation/shift.rb

@@ -0,0 +1,16 @@
+
+module Algorithm::Genetic::Mutation
+	module Shift
+		def mutate(code)
+			index = (rand * code.length).to_i
+			direction = rand <= 0.5 ? -1 : 1
+			begin
+				new_char = (code[index].ord + direction).chr
+			rescue
+				return(code)
+			end
+			code[index] = new_char
+			return code
+		end
+	end
+end

data/lib/algorithm/genetic/mutation/swap.rb

@@ -0,0 +1,11 @@
+
+module Algorithm::Genetic::Mutation
+	module Swap
+		def mutate(code)
+			i1, i2 = (rand * code.length).to_i, (rand * code.length).to_i
+			code[i1], code[i2] = code[i2], code[i1]
+			return code
+		end
+	end
+end
+

data/lib/algorithm/genetic/population.rb

@@ -0,0 +1,94 @@
+module Algorithm
+	module Genetic
+		#
+		# = terminated exception
+		#
+		class Terminated < StandardError
+			attr_reader :gene
+
+			def initialize(gene)
+				@gene = gene
+				super('terminated.')
+			end
+		end
+
+		#
+		# = population management class
+		#
+		class Population
+			include Enumerable
+			attr_reader :generation
+		
+			# constructor of population
+			#
+			# code_length :: size of code
+			# population_size :: size of population
+			# evaluator :: an Evaluator instance or Proc instance returns Evaluator instance
+			# opts :: hash of options
+			#
+			# options:
+			#   :selection :: an array of module name including select method and params
+			#   :crossover :: an array of module name including crossover method and params
+			#   :mutation  :: an array of module name including mutate method and params
+			#   :mutation_chance :: mutation chance (float of 0 to 1)
+			#
+			# need block for generate an initial (random) code of a gene
+			def initialize(population_size, evaluator, opts = {})
+				@evaluator = evaluator
+				@members = Array.new(population_size){
+					Algorithm::Genetic::Gene.new(yield, evaluator, opts)
+				}
+				@generation = 0
+
+				if opts[:selection]
+					@selection_params = opts[:selection].dup
+					selection_module = @selection_params.shift.to_s.capitalize
+					self.extend(Algorithm::Genetic::Selection.const_get(selection_module))
+				end
+			end
+
+			# increment the generation: senection, crossover and mutation
+			def generate
+				@generation += 1
+				select!
+				crossover
+				mutate
+				sort!
+			end
+
+			# iterate each member
+			def each
+				return @members.each unless block_given?
+				@members.each{|m| yield m }
+			end
+		
+		private
+			def sort!
+				@members.sort! do |a, b|
+					b.fitness <=> a.fitness
+				end
+			end
+
+			def select!
+				@members = select(@members, *@selection_params) do |a, b|
+					b.fitness <=> a.fitness
+				end
+			end
+
+			def crossover
+				@members += @members[0].crossover_with(@members[1])
+			end
+
+			def mutate
+				@members.each do |m|
+					m.mutate!
+					if m.terminated?
+						sort!
+						raise Terminated.new(m)
+					end
+				end
+			end
+		end
+	end
+end
+

data/lib/algorithm/genetic/selection/elite.rb

@@ -0,0 +1,8 @@
+
+module Algorithm::Genetic::Selection
+	module Elite
+		def select(members, num)
+			(block_given? ? members.sort{|a, b| yield a, b } : members.sort)[0, num]
+		end
+	end
+end

data/lib/algorithm/genetic/version.rb

@@ -0,0 +1,5 @@
+module Algorithm
+  module Genetic
+    VERSION = "0.0.1"
+  end
+end

data/sample/i_love_ruby.rb

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+#
+# Algorithm::Genetic sample: say 'I Love Ruby'
+#
+require 'algorithm/genetic'
+require 'algorithm/genetic/selection/elite'
+require 'algorithm/genetic/crossover/point'
+require 'algorithm/genetic/mutation/shift'
+
+class StringEvaluator < Algorithm::Genetic::Evaluator
+	def initialize(goal)
+		@goal = goal
+	end
+
+	def fitness(gene)
+		total = 0
+		gene.code.each_with_index do |c, i|
+			total -= (c.ord - @goal[i].ord) ** 2
+		end
+		return total
+	end
+
+	def terminated?(gene)
+		gene.code == @goal
+	end
+end
+
+def show(population)
+	puts "Generation: #{population.generation}"
+	population.each do |gene|
+		puts "  #{gene.code.join.inspect} (#{gene.fitness})"
+	end
+	puts
+end
+
+goal = 'I love Ruby'.split(//)
+size = 10
+evaluator = StringEvaluator.new(goal)
+population = Algorithm::Genetic::Population.new(
+	size, evaluator,
+	selection: [:elite, size - 2],
+	crossover: [:point, 1],
+	mutation: [:shift]
+) do
+	(' ' * goal.length).each_byte.map{|c| (rand * 255).to_i.chr}
+end
+show(population)
+begin
+	loop do
+		population.generate
+		show(population)
+	end
+rescue Algorithm::Genetic::Terminated => e
+	puts "Got '#{e.gene.code.join}' at generation #{population.generation}."
+end

data/sample/tsp.rb

@@ -0,0 +1,94 @@
+#!/usr/bin/env ruby
+#
+# Algorithm::Genetic sample: traveling salesman problem
+#
+require 'algorithm/genetic'
+require 'algorithm/genetic/selection/elite'
+require 'algorithm/genetic/crossover/order'
+require 'algorithm/genetic/mutation/swap'
+
+class City
+	attr_reader :name, :x, :y
+
+	def initialize(name, x, y)
+		@name, @x, @y = name, x, y
+	end
+
+	def distance_with(city)
+		Math.sqrt((@x - city.x) ** 2 + (@y - city.y) ** 2)
+	end
+end
+
+class RouteEvaluator < Algorithm::Genetic::Evaluator
+	def initialize(start)
+		@start = start
+	end
+
+	def fitness(gene)
+		total = 0.0
+		prev = @start
+		gene.code.each do |city|
+			total += prev.distance_with(city)
+			prev = city
+		end
+		total += prev.distance_with(@start)
+		return -total
+	end
+
+	def terminated?(gene)
+		# cannot know termination by gene.
+		# stop yourself by limitation of generation count
+		return false
+	end
+end
+
+def distance_char(city1, city2)
+	'_' * (city1.distance_with(city2) / 20)
+end
+
+def show(population, start)
+	puts "Generation: #{population.generation}"
+	population.each do |cities|
+		printf('%7.2f %s', -cities.fitness, start.name)
+		prev = start
+		cities.code.map do |city|
+			print distance_char(prev, city)
+			print city.name
+			prev = city
+		end
+		print distance_char(prev, start)
+		puts start.name
+	end
+	puts
+end
+
+#
+# create all cities
+#
+name = '@' # previous of 'A'
+cities = Array.new(20).map do
+	City.new(name.succ!.dup, 0.0 + rand(100), 0.0 + rand(100))
+end
+start = cities.shift
+
+size = 10
+evaluator = RouteEvaluator.new(start)
+population = Algorithm::Genetic::Population.new(
+	size, evaluator,
+	selection: [:elite, size - 2],
+	crossover: [:order],
+	mutation: [:swap],
+	mutation_chance: 0.3
+) do
+	cities.shuffle
+end
+
+show(population, start)
+print "press any key to start."
+gets
+1000.times do
+	population.generate
+	show(population, start)
+end
+printf('distance: %1.2f ', -population.first.fitness)
+puts("#{start.name}-#{population.first.code.map{|city| city.name}.join('-')}-#{start.name}")