gegene 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0599f2cbca99f724dacc4eb7f106122174108ea8
-  data.tar.gz: c32d27d42638c9e12e292f615002663b8eae4581
+  metadata.gz: 99c7470e76700e9f8111387771e1fdd0fde4c2ff
+  data.tar.gz: f88f83cea4ea0ae391c2e7f0d70457c1c3e99333
 SHA512:
-  metadata.gz: 0144049db0f4c7634d21815c3b1c0d3e8b5347fb2167d82219b25e52112d1594f21710948e63e58c4196420ea63148d5fa0fab7ec14ade177982316f0e1c6583
-  data.tar.gz: 3f54ddadf7ced812bd993cdc939a73ddebc26063302a502f753cef97e4d2d03c212616c241e9ecd1f97d130b9a8119661317b5491deed85006da3ef12a408049
+  metadata.gz: 6806f2aece4b0e729c76b1fbca4a28c40bd0e08eb1fee29e3194dd7f7bb5c75bc6bb8f40de46d0b634adb6ff29ab7843dcd803bdac1de5e5f173d944a293b733
+  data.tar.gz: dd58f6acc164a80abf371428d829e57c9096ffff152295a37c62ed1a58ec5e96831e0d893f59529e2a6329cb5d76348cc0e1a799bc0e03f68950048f1dd40ffc

data/Gemfile.lock

@@ -0,0 +1,34 @@
+PATH
+  remote: .
+  specs:
+    gegene (1.2.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.2.4)
+    multi_json (1.8.2)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.6)
+    rspec-expectations (2.14.3)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.4)
+    simplecov (0.7.1)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.7.1)
+    simplecov-html (0.7.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  gegene!
+  rspec
+  rspec-mocks
+  simplecov
+
+BUNDLED WITH
+   1.12.5

data/README.md

@@ -0,0 +1,197 @@
+gegene
+======
+A generic framework for genetic algorithm fast development in Ruby
+
+Introduction
+------------
+
+>In the computer science field of artificial intelligence, a genetic algorithm (GA) is a search heuristic that mimics the process of natural selection. This heuristic (also sometimes called a metaheuristic) is routinely used to generate useful solutions to optimization and search problems.[1] Genetic algorithms belong to the larger class of evolutionary algorithms (EA), which generate solutions to optimization problems using techniques inspired by natural evolution, such as inheritance, mutation, selection, and crossover.
+
+from http://en.wikipedia.org/wiki/Genetic_algorithm
+
+In order to offer a fast prototyping framework for genetic algorithm, I created gegene (French shorter for Eugene).
+
+With gegene, all you got to do in order to use genetic algorithms to solve a problem is:
+
+1. define the genome of your solutions in terms of gene type and chromosome organisation (eq: write an array of hashes)
+2. define the way you would like to evaluate each individuals (eq: write a fitness function which takes a karyotype as parameter)
+3. create a population of individuals (eq: instantiates a Population object)
+4. evolve ! (eq: run Population.evolve())
+5. all your solutions are sorted by fitness value (fittest first) in Population.karyotypes.
+
+Overview
+--------
+
+### Example
+
+In the following code, we use gegene to find *a* and *b* so _a*a + b = 12_, with *a* included in [0,5], and *b* included in [-5,5]:
+```Ruby
+require 'gegene'
+FITNESS_TARGET = 1 / 0.001
+population = Population.new(
+    50,
+    [{a:Gene.Integer(0, 5)},{b:Gene.Integer(-5,5)}],
+    lambda {|k| 1 / (0.001 + (12-(k[:a]**2+k[:b])).abs) }
+  )
+population.set_mutation_rate(0.5).set_fitness_target(FITNESS_TARGET).evolve(50)
+bk = population.karyotypes[0]
+warn "a:#{bk[:a]} b:#{bk[:b]} => a*a + b = #{bk[:a]**2+bk[:b]}"
+```
+
+The result could be :
+
+	a:4 b:-4 => a*a + b = 12
+
+or
+
+	a:3 b:3 => a*a + b = 12
+
+_Note: this source code is available 'in example/simple.rb'_
+
+### Features
+
+At this very moment, gegene features:
+
+* Inheritance
+* Mutation
+* Cross over
+* Non linear selection
+* An optional fitness value cache, to avoid extra computing
+* A pretty cool name
+
+### What will come next ?
+
+My next moves will be: 
+
+* your call
+
+Tutorial
+--------
+
+*This tutorial is available in 'example/one_max.rb'*
+
+Let's consider the one max problem (an explanation can be found here : http://tracer.lcc.uma.es/problems/onemax/onemax.html ), where the goal is  maximizing the number of ones of an array of bits.
+
+For this example, we'll use an array of 3 bits, named v1, v2 and v3.
+Obviously, the solution to this problem would be:
+
+* v1 = 1
+* v2 = 1
+* v3 = 1
+
+Let's see if gegene is able to figure this out !
+
+### Setting the genome description
+
+First of all, you will need to add the following line to the top of your script:
+```Ruby
+require 'gegene'
+```
+
+If your lib path contains gegene, your script should still execute well.
+
+Then, we have to figure out a way to describe the potential solutions to this problem.
+Obviously, there is three variables to this problem (v1, v2 & v3), so we will use a genome containing 3 genes.
+Each of these gene allow 0 or 1 as allele's value, so we will use an integer gene, whose range of values will be [0,1]. Do not add this source code to your script for the moment:
+```Ruby
+Gene.Integer(0, 1)
+```
+
+In order to maximize the diversity of combinations, well describe three chromosome descriptions, each of them containing an integer gene and named after the corresponding variable:
+```Ruby
+# Follow a genome description for the one max problem:
+genome_description = [
+    { v1: Gene.Integer(0,1) },
+    { v2: Gene.Integer(0,1) },
+    { v3: Gene.Integer(0,1) }
+  ]
+```
+
+### Defining a fitness function
+
+Next, we have to define the fitness function. This one is a pretty simple one, as we can sum the three values in order to score a karyotype:
+```Ruby
+# Here is the fitness function of the one max problem:
+def fitness(karyotype)
+  karyotype[:v1] + karyotype[:v2] + karyotype[:v3]
+end
+```
+
+_Note that each of the karyotype 's allele can be accessed through its gene name_
+The parameter of the fitness function is a [karyotype]( http://en.wikipedia.org/wiki/Karyotype). It contains all the chromosomes of a specific individual of our population.
+
+### Creating and making a population evolve
+
+Now that we are happy with our genome and fitness function, we have to create a population:
+```Ruby
+# We create a population of six individuals with the previous desc & func:
+population = Population.new(6, genome_description, method(:fitness))
+````
+
+We already know the result of our fitness function for the best solution, so we can set the fitness target of our population. If the fitness target is reached, the population will stop evolving. A good usage to the fitness target is setting it to an acceptable score to avoid endless processing of a population with very small enhancement of the solutions.
+```Ruby
+# As we known the best solution for the one max problem, we set a
+# fitness target of 3 (1+1+1).
+population.fitness_target = 3
+````
+
+As the population contains only 6 individuals, we set a high mutation rate in order to introduce "new blood" at each iteration:
+```Ruby
+# As the population is quite small, we add a little more funk to our
+# evolution process by setting a 30% mutation rate
+population.mutation_rate = 0.3
+```
+
+Let me introduce to you.... Evolution !
+```Ruby
+# Let's go for some darwinist fun !
+population.evolve(10)
+````
+
+In order to examine the best solution found, you can check the array of karyotypes (sorted by fitness value) describing the current population state:
+```Ruby
+# population.karyotypes is sorted by fitness score, so we can assume that
+# the first element is the fittest
+best_karyotype = population.karyotypes[0]
+
+puts "Best karyotype scored #{best_karyotype.fitness}:"
+[:v1, :v2, :v3].each {|x| puts "    #{x.to_s}:#{best_karyotype[x]}" }
+````
+
+This code should display:
+
+	Best karyotype scored 3:
+    	v1:1
+    	v2:1
+    	v3:1
+
+Congratulations for your first evolution with gegene !
+
+More details on the genes
+-------------------------
+
+### Available Gene types
+
+* Gene.Integer(min, max): An integer, randomly selected in the range [min, max].
+* Gene.Float(min, max): A float, randomly selected in the range [min, max].
+* Gene.Enum(values_array): A value from a set of values provided in an array.
+
+### Adding new gene types
+
+If needed, you are able to add gene type to any project.
+In order to do so, you have to create a class inheriting from the Gene class.
+This class *must* provide implementation for two methods:
+
+````Ruby
+def random_allele_value()
+end
+````
+Create a random value, according to the set of rules you choosed (ex: BooleanGene should return true or false, on a random basis)
+
+````Ruby
+def mutate(previous_value)
+end
+````
+Create a mutated value, which can (but not necessarily) depends on the previous value an allele used to carry.
+
+An example of gene type creation is available in 'example/adding_gene_type.rb'.

data/gegene.gemspec

@@ -0,0 +1,25 @@
+$LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
+require 'gegene/version'
+Gem::Specification.new do |s|
+  s.name        = 'gegene'
+  s.version     = Gegene::Version::STRING
+  s.platform    = Gem::Platform::RUBY
+  s.summary     = "Genetic algorithm helpers"
+  s.description = "Framework for genetic algorithm fast development"
+  s.authors     = ["Alexandre Ignjatovic"]
+  s.email       = 'alexandre.ignjatovic@gmail.com'
+  s.license     = 'MIT'
+  s.files = `git ls-files`.split($RS).reject do |file|
+    file =~ %r{^(?:
+    spec/.*
+    |Gemfile
+    |Rakefile
+    |\.rspec
+    |\.gitignore
+    |\.rubocop.yml
+    |\.rubocop_todo.yml
+    |.*\.eps
+    )$}x
+  end
+  s.homepage    = 'https://github.com/bankair/gegene'
+end

data/lib/allele.rb

@@ -1,16 +1,17 @@
+# Specific value for a specific gene
 class Allele
   attr_accessor :value
   def initialize(gene, value)
     @gene = gene
     @value = value
   end
-  
+
   def mutate
     @value = @gene.mutate(@value)
   end
-  
+
   def copy
     # /!\ if @value is a ref, its underlying object won't be copied
     Allele.new(@gene, @value)
   end
-end
+end

data/lib/chromosome.rb

@@ -1,70 +1,59 @@
 require 'gene'
 require 'allele'
+require 'forwardable'
 
-# This class represent a chromosome, which contains several allele (gene's values)
-# and is able to mutate, and to cross over.
+# This class represent a chromosome, which contains several allele
+# (gene's values) and is able to mutate, and to cross over.
 class Chromosome
-  
+  extend Forwardable
+
+  def_delegators :@alleles, :size, :[], :each_with_index, :map
   # Construct a chromosome from an array of alleles
   def initialize(alleles)
-    raise "this constructor expect an array of alleles as input" unless
-      alleles.is_a?(Array)
+    unless alleles.is_a?(Array)
+      puts alleles.inspect
+      raise 'this constructor expect an array of alleles as input'
+    end
     @alleles = alleles
   end
-  
+
   # Copy the current chromosome and all its alleles
   def copy
-    Chromosome.new(@alleles.map{|allele| allele.copy })
+    Chromosome.new(map(&:copy))
   end
-  
+
   # Create a random chromosome from a description
-  def Chromosome.create_random_from(description)
-    Chromosome.new(description.map{|gene| gene.create_random() })
+  def self.create_random_from(description)
+    new(description.map(&:create_random))
   end
-  
-  # Returns the allele at a specific position
-  def [](gene_position)
-    @alleles[gene_position]
-  end
-  
-  # Number of underlying alleles
-  def size
-    @alleles.size
-  end
-  
+
   # Mutate a randomly selected allele of the current chromosome
   def mutate
-    allele_index = rand @alleles.size
-    @alleles[allele_index].mutate()
+    @alleles[rand size].mutate
   end
-  
+
   # Aggregate all alleles values
-  def aggregated_alleles()
-    @alleles.map {|a| a.value}.join(";")
+  def aggregated_alleles
+    map(&:value).join(';')
   end
-  
+
   # Cross over two chromosomes to provide a new one
-  def Chromosome.cross_over(chromosome_a, chromosome_b)
-    if rand(2) == 0 then
-      chromosome_a, chromosome_b =
-        [chromosome_b, chromosome_a]
-    end
-    size = chromosome_a.size
-    if size < 2 then
-      return chromosome_a.copy
-    elsif size == 2 then
-      return Chromosome.new([chromosome_a[0],chromosome_b[1]])
-    else
-      swap_index = rand(size-1)
-      index = 0
-      new_alleles = []
-      while (index < size) do
-        new_alleles.push(
-          (index <= swap_index ? chromosome_a : chromosome_b)[index].copy)
-        index += 1
-      end
-      return Chromosome.new(new_alleles)
-    end
+  def self.cross_over(chromo_a, chromo_b)
+    chromo_a, chromo_b = randomize_chromosomes(chromo_a, chromo_b)
+    size = chromo_a.size
+    return chromo_a.copy if size < 2
+    return new([chromo_a[0], chromo_b[1]].map!(&:copy)) if size == 2
+    cross_over_impl(chromo_a, chromo_b, size)
+  end
+
+  def self.cross_over_impl(chromosome_a, chromosome_b, size)
+    swap_index = rand(size - 1)
+    new(chromosome_a.each_with_index.map do |from_a, index|
+      (index <= swap_index ? from_a : chromosome_b[index]).copy
+    end)
+  end
+
+  def self.randomize_chromosomes(*chromosomes)
+    chromosomes.sort_by! { rand }
   end
-  
-end
+end

data/lib/gegene.rb

@@ -1,2 +1,3 @@
 require 'gene'
-require 'population'
+require 'population'
+require 'version'

data/lib/gegene/version.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+module Gegene
+  # This module holds the Ihasa version information.
+  module Version
+    STRING = '1.2.0'
+
+    module_function
+
+    def version(debug = false)
+      STRING
+    end
+  end
+end

data/lib/gene.rb

@@ -1,17 +1,28 @@
-
-class Gene  
-  def mutate(allele)
-    raise "the 'mutate' function must be overloaded in the inheriting class."
+# A Gene can take different values, randomly mutate.
+class Gene
+  def mutate(_allele)
+    raise_missing_impl :mutate
   end
 
   def random_allele_value
-    raise "the 'random_allele_value' function must be overloaded in the inheriting class."
+    raise_missing_impl :random_allele_value
   end
+
   def create_random
-    Allele.new(self, self.random_allele_value)
+    Allele.new(self, random_allele_value)
+  end
+
+  private
+
+  MISSING_IMPL_ERR_FMT =
+    "the '%s' function must be overloaded in the inheriting class.".freeze
+
+  def raise_missing_impl(func)
+    raise MISSING_IMPL_ERR_FMT % func
   end
 end
 
+# Root class for all numeric genes
 class NumericGene < Gene
   attr_accessor :min, :max
   def initialize(min, max)
@@ -22,51 +33,59 @@ class NumericGene < Gene
 
   def mutate(previous_value)
     next_value = random_allele_value
-    while next_value == previous_value do
-      next_value = random_allele_value
-    end
+    next_value = random_allele_value while next_value == previous_value
     next_value
   end
-end 
+end
 
+# Integer gene class
 class IntegerGene < NumericGene
-  def initialize(min, max) super(min, max) end
-  
-  def random_allele_value() rand(self.min..self.max) end
+  def random_allele_value
+    rand(min..max)
+  end
 end
 
+# Float gene class
 class FloatGene < NumericGene
-  def initialize(min, max) super(min, max) end
-  
   def random_allele_value
-    rand() * (self.max - self.min) + self.min
+    rand * (max - min) + min
   end
 end
 
+# Enumeration gene class
 class EnumGene < Gene
   attr_accessor :enum_values
 
   def initialize(enum_values)
-    raise "EnumGene initialization require an Array" unless enum_values.is_a? Array
-    raise "EnumGene require at least two values" unless enum_values.size > 1
+    unless enum_values.is_a? Array
+      raise 'EnumGene initialization require an Array'
+    end
+    raise 'EnumGene require at least two values' unless enum_values.size > 1
     @enum_values = enum_values
   end
-  
+
   def random_allele_value
     @enum_values[rand @enum_values.size]
   end
-  
+
   def mutate(previous_value)
-    new_value = self.random_allele_value
-    while new_value == previous_value
-      new_value = self.random_allele_value
-    end
+    new_value = random_allele_value
+    new_value = random_allele_value while new_value == previous_value
     new_value
   end
 end
 
+# Gene class build methods
 class Gene
-  def self.Integer(min, max) IntegerGene.new(min, max) end
-  def self.Float(min, max) FloatGene.new(min, max) end
-  def self.Enum(enum_values) EnumGene.new(enum_values) end
-end
+  def self.Integer(min, max)
+    IntegerGene.new(min, max)
+  end
+
+  def self.Float(min, max)
+    FloatGene.new(min, max)
+  end
+
+  def self.Enum(enum_values)
+    EnumGene.new(enum_values)
+  end
+end

data/lib/genome.rb

@@ -3,36 +3,43 @@ require 'Karyotype'
 # This class stands for the genome. It is a description of all
 # the gene describing a specific population.
 class Genome
-  
   DEFAULT_CROSS_OVER_RATE = 0.01
-  
+  attr_accessor :gene_positions
+  attr_reader :cross_over_rate
+
   def initialize(genome_description)
-    raise "Genome description MUST be an Array" unless genome_description.is_a? Array
-    @chromosomes_description = []
-    @gene_positions = {}
-    genome_description.each_with_index do |chomosome_hash, chromosome_position|
-      gene_array = []
-      chomosome_hash.keys.each_with_index do |gene_name, gene_position|
-        @gene_positions[gene_name] = [chromosome_position, gene_position]
-        gene_array << chomosome_hash[gene_name]
-      end
-      @chromosomes_description << gene_array
+    unless genome_description.is_a? Array
+      raise 'Genome description MUST be an Array'
     end
+    initialize_genes_and_chromosomes_from! genome_description
     @cross_over_rate = DEFAULT_CROSS_OVER_RATE
   end
-  attr_accessor :gene_positions
-  attr_reader :cross_over_rate
+
   def cross_over_rate=(rate)
-    raise "cross_over_rate must be included in [0,1]" unless rate.between?(0,1)
+    raise 'cross_over_rate must be included in [0,1]' unless rate.between?(0, 1)
     @cross_over_rate = rate
   end
-  
+
   def get_gene_position(gene_name)
     @gene_positions[gene_name]
   end
-  
+
   def create_random_karyotype
     Karyotype.create_random_from(self, @chromosomes_description)
   end
-  
-end
+
+  private
+
+  def initialize_genes_and_chromosomes_from!(genome_description)
+    @chromosomes_description = []
+    @gene_positions = {}
+    genome_description.each_with_index do |chomosome_hash, chromosome_position|
+      gene_array = []
+      chomosome_hash.keys.each_with_index do |gene_name, gene_position|
+        @gene_positions[gene_name] = [chromosome_position, gene_position]
+        gene_array << chomosome_hash[gene_name]
+      end
+      @chromosomes_description << gene_array
+    end
+  end
+end

data/lib/karyotype.rb

@@ -5,34 +5,34 @@ require 'digest/md5'
 class Karyotype
   attr_accessor :chromosomes
   attr_accessor :fitness
-  
+
   def initialize(genome, chromosomes_description)
     @genome = genome
     @chromosomes_description = chromosomes_description
   end
   private :initialize
-  
+
   # Copy self and all its chromosomes to a new karyotype
   def copy
     karyotype = Karyotype.new(@genome, @chromosomes_description)
-    karyotype.chromosomes = self.chromosomes.map{|chromosome| chromosome.copy}
+    karyotype.chromosomes = chromosomes.map(&:copy)
     karyotype
   end
-  
+
   def to_s
-    @genome.gene_positions.keys.map{|gn| "#{gn}=>#{self[gn]}"}.join';'
+    @genome.gene_positions.keys.map { |gn| "#{gn}=>#{self[gn]}" }.join';'
   end
-  
+
   # Create a random karyotype from a specific genome an its associated
   # chromosomes description
-  def Karyotype.create_random_from(genome, chromosomes_description)
+  def self.create_random_from(genome, chromosomes_description)
     karyotype = Karyotype.new(genome, chromosomes_description)
     karyotype.chromosomes = chromosomes_description.map {|description|
       Chromosome.create_random_from(description)
     }
     karyotype
   end
-  
+
   # Return the allele value of a specific named gene
   # We strongly recommand using symbols as gene name
   def [](gene_name)
@@ -40,44 +40,44 @@ class Karyotype
     chromosome_position, gene_position =
       @genome.get_gene_position(gene_name)
     return nil if chromosome_position.nil? || gene_position.nil?
-    return @chromosomes[chromosome_position][gene_position].value
+    @chromosomes[chromosome_position][gene_position].value
   end
-  
+
   # Breeding function
   # Create a new karyotype based on self and an other
   def +(other)
     child = Karyotype.new(@genome, @chromosomes_description)
     child.chromosomes = []
-    other.chromosomes.each_with_index { |chromosome, index|
-      child_chromosome = nil
-      # Randomly copy chromosomes from dad or mom to child
-      if (rand(100) / 100.0) < @genome.cross_over_rate then
-        # Crossing over required
-        child_chromosome =
-          Chromosome.cross_over(chromosome, chromosomes[index])
-      else
-        # Standard breeding via random selection
-        child_chromosome = (rand(2)==0?chromosome : chromosomes[index]).copy
-      end
-      child.chromosomes.push(child_chromosome)
-    }
+    other.chromosomes.each_with_index do |chromosome, index|
+      child.chromosomes.push(select_chromosome(chromosome, chromosomes[index]))
+    end
     child
   end
-  
+
   # Aggregate all the allele into a md5 hash value
-  def to_md5()
-    if (@hash_value.nil?) then
-      @hash_value = @chromosomes.map{ |chromosome|
-        chromosome.aggregated_alleles
-      }.join(";")
+  def to_md5
+    if @hash_value.nil?
+      @hash_value = @chromosomes.map(&:aggregated_alleles).join(';')
       @hash_value = Digest::MD5.hexdigest(@hash_value)
     end
     @hash_value
   end
-  
+
   # Randomly mutate an allele of a randomly selected chromosome
   def mutate
     @chromosomes[rand @chromosomes.size].mutate
     self
   end
-end
+
+  private
+
+  def select_chromosome(chromosome_a, chromosome_b)
+    if (rand(100) / 100.0) < @genome.cross_over_rate
+      # Crossing over required
+      Chromosome.cross_over(chromosome_a, chromosome_b)
+    else
+      # Standard breeding via random selection
+      (rand(2) == 0 ? chromosome_a : chromosome_b).copy
+    end
+  end
+end

data/lib/population.rb

@@ -1,5 +1,5 @@
 require 'genome'
-
+# Stand for a whole population used for an evolution experiment
 class Population
   DEFAULT_MUTATION_RATE = 0.01
   DEFAULT_KEEP_ALIVE_RATE = 0.1
@@ -8,83 +8,99 @@ class Population
 
   attr_accessor :fitness_target, :karyotypes, :force_fitness_recalculation
   attr_reader :mutation_rate, :keep_alive_rate
-  
+
   # mutation rate setter function
   # Accept values in the range [0,1]
   def mutation_rate=(value)
-    raise "mutation_rate value must be included in [0,1]" unless value.between?(0,1)
-    @mutation_rate = value
+    @mutation_rate = validate!(:mutation_rate, value)
   end
-  
+
   # keep alive rate setter function
   # Accept values in the range [0,1]
   def keep_alive_rate=(value)
-    raise "mutation_rate value must be included in [0,1]" unless value.between?(0,1)
-    @keep_alive_rate = value
-  end 
-
-
-  # Run the fitness function for all karyotypes, and sort it by fitness
-  def evaluate
-    if @force_fitness_recalculation then
-      @karyotypes.each do |karyotype|
-        karyotype.fitness = @fitness_calculator.call(karyotype)
-        @fitness_hash[karyotype.to_md5()] = karyotype.fitness
-      end
-    else     
-      @karyotypes.each do |karyotype|
-        if karyotype.fitness.nil? then
-          if @fitness_hash[karyotype.to_md5()].nil? then
-            karyotype.fitness = @fitness_calculator.call(karyotype)
-            @fitness_hash[karyotype.to_md5()] = karyotype.fitness
-          else
-            karyotype.fitness = @fitness_hash[karyotype.to_md5()]
-          end
-        end
-      end
-    end
-    @karyotypes.sort! { |x,y| y.fitness <=> x.fitness }
+    @keep_alive_rate = validate!(:keep_alive_rate, value)
   end
 
-  private :evaluate
-
   def initialize(size, genome, fitness_calculator)
-    raise "size must be strictly positive." if size < 1
+    raise 'size must be strictly positive.' if size < 1
     @fitness_hash = {}
     @force_fitness_recalculation = DEFAULT_FORCE_FITNESS_RECALCULATION
     @mutation_rate = DEFAULT_MUTATION_RATE
     @keep_alive_rate = DEFAULT_KEEP_ALIVE_RATE
     @genome = Genome.new(genome)
     @fitness_calculator = fitness_calculator
-    @karyotypes = Array.new(size){ @genome.create_random_karyotype }
+    @karyotypes = Array.new(size) { @genome.create_random_karyotype }
     evaluate
   end
 
-  def set_mutation_rate(rate)
-    raise "mutation_rate value must be included in [0,1]" unless rate.between?(0,1)
-    
-    @mutation_rate= rate
-    self
+  %i(mutation_rate keep_alive_rate
+     fitness_target force_fitness_recalculation).each do |sym|
+    define_method("set_#{sym}") { |value| tap { |o| o.send("#{sym}=", value) } }
   end
 
-  def set_keep_alive_rate(rate)
-    raise "keep_alive_rate must be included in [0,1]" unless rate.between?(0,1)
-    @keep_alive_rate = rate
-    self
+  def size
+    @karyotypes.size
   end
 
-  def set_fitness_target(target)
-    @fitness_target = target
+  # This function make ou population evolving by:
+  # * Selecting and breeding the fittest karyotypes
+  # * Running the fitness evaluation on all the newly created karyotyopes
+  # The selection process include three subprocesses:
+  # * Selecting the fittest individuals to keep alive
+  # * Mutating randomly (linear) selected individuals
+  # * Breeding randomly (fitness weighted) selected individuals
+  def evolve(iterations = DEFAULT_EVOLVE_ITERATIONS)
+    i = 1
+    while (i <= iterations) &&
+          (@fitness_target.nil? || @fitness_target > @karyotypes[0].fitness)
+      evolve_impl
+      i += 1
+    end
     self
   end
 
-  def set_force_fitness_recalculation(target)
-    @force_fitness_recalculation = target
-    self
+  private
+
+  NO_FITNESS = :no_fitness
+
+  # Run the fitness function for all karyotypes, and sort it by fitness
+  def evaluate
+    if @force_fitness_recalculation
+      @karyotypes.each { |karyotype| update!(karyotype, fitness(karyotype)) }
+    else
+      @karyotypes.each do |karyotype|
+        update!(karyotype, cached_fitness(karyotype)) if karyotype.fitness.nil?
+      end
+    end
+    @karyotypes.sort_by! { |karyotype| - karyotype.fitness }
   end
 
-  def size
-    @karyotypes.size
+  def update!(karyotype, fitness)
+    karyotype.fitness = fitness
+    @fitness_hash[karyotype.to_md5] = karyotype.fitness
+  end
+
+  def fitness(karyotype)
+    @fitness_calculator.call(karyotype)
+  end
+
+  def cached_fitness(karyotype)
+    @fitness_hash.fetch(karyotype.to_md5) { fitness karyotype }
+  end
+
+  def evolve_impl
+    # Keeping alive a specific amount of the best karyotypes
+    keep_alive_count = Integer(@karyotypes.size * @keep_alive_rate)
+    mutation_count = Integer(@karyotypes.size * @mutation_rate)
+    @karyotypes = build_new_karyotypes(keep_alive_count, mutation_count)
+    evaluate
+  end
+
+  def build_new_karyotypes(keep_alive_count, mutation_count)
+    remaining = @karyotypes.size - mutation_count - keep_alive_count
+    @karyotypes[0, keep_alive_count]
+      .concat(Array.new(mutation_count) { create_random_mutation })
+      .concat(Array.new(remaining) { random_breed })
   end
 
   def linear_random_select
@@ -95,60 +111,19 @@ class Population
     linear_random_select.copy.mutate
   end
 
-  private :linear_random_select, :create_random_mutation
-
   def fitness_weighted_random_select
     @karyotypes[
       @karyotypes.size -
-        Integer(Math.sqrt(Math.sqrt(1 + rand(@karyotypes.size**4 - 1))))
+      Integer(Math.sqrt(Math.sqrt(1 + rand(@karyotypes.size**4 - 1))))
     ]
   end
-  
+
   def random_breed
     fitness_weighted_random_select + fitness_weighted_random_select
   end
 
-  private :fitness_weighted_random_select, :random_breed
-
-  # This function make ou population evolving by:
-  # * Selecting and breeding the fittest karyotypes
-  # * Running the fitness evaluation on all the newly created karyotyopes
-  # The selection process include three subprocesses:
-  # * Selecting the fittest individuals to keep alive
-  # * Mutating randomly (linear) selected individuals
-  # * Breeding randomly (fitness weighted) selected individuals
-  def evolve(iterations = DEFAULT_EVOLVE_ITERATIONS)
-    i = 1
-    while (i <= iterations) &&
-      (@fitness_target.nil? || @fitness_target > @karyotypes[0].fitness) do
-        evolve_impl
-        i += 1
-    end
-    self
-  end
-
-  def evolve_impl
-    new_population = []    
-
-    # Keeping alive a specific amount of the best karyotypes
-    keep_alive_count = Integer(@karyotypes.size * @keep_alive_rate)
-    if keep_alive_count > 0 then
-      @karyotypes[0, keep_alive_count].each {|karyotype| new_population.push(karyotype)}
-    end
-
-    mutation_count = Integer(@karyotypes.size * @mutation_rate)
-    (0..mutation_count-1).each {
-      new_population.push create_random_mutation
-    }
-
-    remaining = @karyotypes.size-mutation_count-keep_alive_count
-    (0..remaining-1).each {
-      child = random_breed
-      new_population.push child      
-    }
-    @karyotypes = new_population
-    evaluate
+  def validate!(label, value)
+    raise "#{label} value must be included in [0,1]" unless value.between?(0, 1)
+    value
   end
-  private :evolve_impl
-
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gegene
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Alexandre Ignjatovic
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-01 00:00:00.000000000 Z
+date: 2016-08-03 00:00:00.000000000 Z
 dependencies: []
 description: Framework for genetic algorithm fast development
 email: alexandre.ignjatovic@gmail.com
@@ -16,17 +16,23 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- example/adding_gene_type.rb
+- example/one_max.rb
+- example/simple.rb
+- gegene.gemspec
 - lib/allele.rb
 - lib/chromosome.rb
 - lib/gegene.rb
+- lib/gegene/version.rb
 - lib/gene.rb
 - lib/genome.rb
 - lib/karyotype.rb
 - lib/population.rb
-- example/adding_gene_type.rb
-- example/one_max.rb
-- example/simple.rb
-- LICENSE.txt
+- releases/gegene-1.0.0.gem
+- releases/gegene-1.1.0.gem
 homepage: https://github.com/bankair/gegene
 licenses:
 - MIT
@@ -47,7 +53,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.10
+rubygems_version: 2.6.5
 signing_key: 
 specification_version: 4
 summary: Genetic algorithm helpers