evopop 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3478b3b769ad2fd3806bf11406bbcc30cea0e9a8
-  data.tar.gz: bf51dd7b58cfe959097ec16db90d38f761f42ffc
+  metadata.gz: 04d8cc00d713a77a686106e3be50d26d95889ec0
+  data.tar.gz: 0ee8bc2bca81622f24aa80184fa942fce901064d
 SHA512:
-  metadata.gz: 15a5dfce03cb291458423c9cde9a7e4bfc4d62acc80ff2c16c54e68e877d76ef6bf6f4ba7061bf20d47d159dbf40d07bf155262c8b86ba139220be52a332e509
-  data.tar.gz: dac566a6ab3e9052d71b7e16b6055c6648b09e2228b2349d3a153c149e285d2df5dcfbcf10c7fd78a021de189a50a77797726fcb26cb7906a0923b041d416e48
+  metadata.gz: 2cae28bdfd5bc8d7e9aa431bfd2ff5765cbe7c5e4a7e2e1f28fb07269b8b42daf90e0554c772dfbe060735c3a278937bdf59752a192c1e623dacce55fd51679f
+  data.tar.gz: 6d418afe3bf3d4ec71e1e0f10d6877528fba2206759672d6299b27957e3d4f7e508740c5717fb13fab832933d4ebde93dbadf20849f52198950153f189ad9600

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Elvin Lucero
+
+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/README.md

@@ -0,0 +1,42 @@
+Evopop
+------------------------
+
+This is a library for implementing simple genetic algorithms to evolve over a fitness function.
+
+
+``` ruby
+
+require 'evopop'
+
+# Initialize the population to be trained with good defaults.
+population = Population.new
+population.population_size = 1000
+population.dna_len = 2
+population.max_generations = 1000
+population.initial_range_min = -10_000.0
+population.initial_range_max = 10_000.0
+population.mutation_range_min = -10.0
+population.mutation_range_max = 10.0
+population.mutation_num = 10
+population.crossover_params = { ordinal: (DNA_LEN / 2) }.freeze
+population.crossover_function = Crossover.method(:one_point)
+population.fitness_function = proc do |dna|
+  Math.sin(dna[0]) + Math.cos(dna[1])
+end
+
+# Initialize the population
+population.create
+
+# Train a population for population.max_generations.
+(0...population.max_generations).each do |i|
+  population.train
+  population.crossover
+  population.mutate if i != population.max_generations - 1
+end
+
+# Sort and print out candidate with highest fitness in the last generation.
+population.train
+puts "Finished #{population.max_generations} generations with the fittest candidate with a dna of #{population.candidates[0].dna} and a fitness of #{population.candidates[0].fitness}."
+
+
+```

data/lib/evopop/candidate.rb

@@ -1,11 +1,11 @@
 # Public: Represents a candidate in the population. Candidates are abstracted
-# as a simple data structure which contains the DNA and fitness over the 
+# as a simple data structure which contains the DNA and fitness over the
 # fitness function.
 class Candidate
   attr_accessor :dna, :fitness
 
   # Simple initialization of candidate object.
-  def initialize(dna=[])
+  def initialize(dna = [])
     @dna = dna
   end
-end
+end

data/lib/evopop/crossover.rb

@@ -1,45 +1,101 @@
 # Represents a collection of well known crossover functions.
-# 
+#
 module Crossover
-
   # Perform 1 point crossover for a pair of candidates at the ordinal.
   # http://en.wikipedia.org/wiki/Crossover_(genetic_algorithm)#One-point_crossover
   def self.one_point(candidates, params)
     ordinal = params[:ordinal]
 
-    # Compose the dna of the first child from the first chunk of the 
+    # Compose the dna of the first child from the first chunk of the
     # first candidate and the second chunk of the second candidate
     dna0_left = candidates[0].dna.take(ordinal)
     dna1_right = candidates[1].dna.drop(ordinal)
-    
-    # Compose the dna of the second child from the first chunk of the 
+
+    # Compose the dna of the second child from the first chunk of the
     # first candidate and the second chunk of the second candidate
     dna1_left = candidates[1].dna.take(ordinal)
     dna0_right = candidates[0].dna.drop(ordinal)
 
     # Initialize and assign DNA to children.
-    children = [Candidate.new(dna = dna0_left + dna1_right), 
-                Candidate.new(dna = dna1_left + dna0_right)]
+    children = [Candidate.new(dna0_left + dna1_right),
+                Candidate.new(dna1_left + dna0_right)]
+
+    children
+  end
+
+  # Perform two point crossover over a pair of candidates. Will output two
+  # children with genes spliced over the crossover points.
 
-    return children
+  def self.two_point(candidates, params)
+    # Ordinals should be stored in params as a comma separated list. I.e. "1,2".
+    # Make sure to sort.
+    ordinals = params[:ordinals].split(',').sort.collect(&:to_i)
+
+    # Initialize and assign the DNA of the children.
+    cdna0 = candidates[0].dna
+    cdna1 = candidates[1].dna
+
+    children = [
+      Candidate.new(cdna0[0..ordinals[0]] + cdna1[(ordinals[0] + 1)..ordinals[1]] + cdna0[(ordinals[1] + 1)..cdna0.length - 1]),
+      Candidate.new(cdna1[0..ordinals[0]] + cdna0[(ordinals[0] + 1)..ordinals[1]] + cdna1[(ordinals[1] + 1)..cdna1.length - 1])
+    ]
+
+    children
   end
 
   # Perform n_point crossover for a pair of candidates. Will output two children from the n_point crossover.
-  # 
+  #
   # Example:
   # n_point
   def self.n_point(candidates, params)
+    ordinals = params[:ordinals].split(',').sort.collect(&:to_i)
 
+    pdna0 = candidates[0].dna
+    pdna1 = candidates[1].dna
+
+    dna_length = candidates[0].dna.length
+
+    cdna0 = []
+    cdna1 = []
+
+    old_ordinal = 0
+    synchronous = ordinals[0] == 0 ? false : true
+
+    ordinals.each do |i|
+      if synchronous
+        cdna0 += pdna0[old_ordinal..i]
+        cdna1 += pdna1[old_ordinal..i]
+      else
+        cdna0 += pdna1[old_ordinal..i]
+        cdna1 += pdna0[old_ordinal..i]
+      end
+
+      synchronous = !synchronous
+      old_ordinal = i + 1
+
+      next if ordinals.last != old_ordinal - 1
+
+      if synchronous
+        cdna0 += pdna0[old_ordinal..dna_length - 1]
+        cdna1 += pdna1[old_ordinal..dna_length - 1]
+      else
+        cdna0 += pdna1[old_ordinal..dna_length - 1]
+        cdna1 += pdna0[old_ordinal..dna_length - 1]
+      end
+    end
+
+    [Candidate.new(cdna0), Candidate.new(cdna1)]
   end
 
-  def self.average(candidates, params)
+  def self.average(candidates, _params)
     child = Candidate.new
     dna_length = candidates[0].dna.length
-    (0...dna_length).each { |j|
-      child.dna << (candidates[0].dna[j] + candidates[1].dna[j])/2.0 # Initialize the dna of the child with the average of the parents' dna.
-    }
 
-    return [child]
-  end
+    (0...dna_length).each do |j|
+      # Initialize the dna of the child with the average of the parents' dna.
+      child.dna << (candidates[0].dna[j] + candidates[1].dna[j]) / 2.0
+    end
 
-end
+    [child]
+  end
+end

data/lib/evopop/population.rb

@@ -1,7 +1,7 @@
 
 # Represents the population that is being trained. Has various methods
 # relevant to training.
-# 
+#
 #
 # Examples
 #   population = Population.new
@@ -22,85 +22,89 @@ class Population
     @initial_range_max = 100
     @mutation_range_min = -10
     @mutation_range_max = 10
-    @mutation_num = (0.10*@population_size).to_i
+    @mutation_num = (0.10 * @population_size).to_i
     @dna_len = 1
-    @crossover_params = {:ordinal => (@dna_len/2)}
+    @crossover_params = { ordinal: (@dna_len / 2) }
 
     @crossover_function = Crossover.method(:one_point)
-    @fitness_function = Proc.new { |dna|
+    @fitness_function = proc do |dna|
       Math.sin(dna[0])
-    }
+    end
+
+    create
 
-    self.create
+    self
   end
 
   # Creates a new population class. Should be called after all the
   # parameters have been set to the attributes.
   def create
-    @candidates = Array.new(@population_size) {|c| 
+    @candidates = Array.new(@population_size) do
       candidate = Candidate.new
-      (0...@dna_len).each {
+      (0...@dna_len).each do
         candidate.dna << Random.rand(@initial_range_min...@initial_range_max)
-      }
+      end
       candidate
-    }
+    end
   end
 
   # Determines the fitness of the population and thereafter sorts it
   # based on fitness descdending (high fitness first, low fitness last).
   def train
     average_fitness = 0
-    @candidates.each { |c|
+    @candidates.each do |c|
       c.fitness = fitness_function.call(c.dna)
-      average_fitness = average_fitness + c.fitness
-    }
-    average_fitness = average_fitness/@population_size
+      average_fitness += + c.fitness
+    end
+
+    average_fitness /= @population_size
 
     @average_fitness << average_fitness
 
-    @candidates = @candidates.sort_by {|c| c.fitness}
+    @candidates = @candidates.sort_by(&:fitness)
     @candidates = @candidates.reverse
   end
 
   # Performs simple mechanism of crossover - in this case picks two
-  # random candidates in from a top percentile of the population and 
+  # random candidates in from a top percentile of the population and
   # performs one point crossover, producing new offspring equal to the
   # population size attribute.
   def crossover
     # Define the candidates that can have children.
-    @candidates = @candidates.take((@population_size*0.75).to_i)
-    
-    new_generation = Array.new
-    
-    (0...@population_size).each {|i|
+    @candidates = @candidates.take((@population_size * 0.75).to_i)
+
+    new_generation = []
+
+    (0...@population_size).each do
       # For each of the top 75% of the population take 2
       couple = @candidates.sample(2)
       params = @crossover_params
 
       children = @crossover_function.call(couple, params)
 
-      new_generation = new_generation + children
-      
+      new_generation += children
+
       # When we go above set population_size, take the first population_size
       # candidates, ignore the rest.
-      if new_generation.length >= self.population_size
-        new_generation = new_generation.take(self.population_size)
+      if new_generation.length >= population_size
+        new_generation = new_generation.take(population_size)
         break
       end
-    }
+    end
+
     @candidates = new_generation
   end
 
-  # Performs simple mutation over the next generation. In this case, 
-  # it either adds or substracts an amount to each dimension given the 
+  # Performs simple mutation over the next generation. In this case,
+  # it either adds or substracts an amount to each dimension given the
   # mutation range attributes.
   def mutate
-    mutated = @candidates.sample(self.mutation_num)
+    mutated = @candidates.sample(mutation_num)
 
-    mutated.each { |c|
-      (0...@dna_len).each {|i|
+    mutated.each do |c|
+      (0...@dna_len).each do |i|
         c.dna[i] = c.dna[i] + Random.rand(@mutation_range_min...@mutation_range_max)
-      }
-    }
+      end
+    end
   end
 end

data/lib/evopop.rb

@@ -2,13 +2,6 @@ require 'evopop/population'
 require 'evopop/candidate'
 require 'evopop/crossover'
 
-class Evopop
-
-  def self.Population 
-    Population
-  end
-
-  def self.Candidate
-    Candidate
-  end
-end
+# Toplevel class for evopop project
+module Evopop
+end

metadata

@@ -1,27 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: evopop
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Elvin Lucero
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-08 00:00:00.000000000 Z
+date: 2016-04-24 00:00:00.000000000 Z
 dependencies: []
 description: A simple library for implementing simple genetic algorithms.
-email: elvinlucero@gmail.com
+email: elvin+evopop@pluots.io
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- LICENSE
+- README.md
 - lib/evopop.rb
-- lib/evopop/population.rb
 - lib/evopop/candidate.rb
 - lib/evopop/crossover.rb
-- test/test_population.rb
-homepage: https://github.com/elvinlucero/evopop
+- lib/evopop/population.rb
+homepage: https://rubygems.org/gems/evopop
 licenses:
 - MIT
 metadata: {}
@@ -31,19 +32,18 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
-summary: Genetic algorithms!
-test_files:
-- test/test_population.rb
+summary: A simple library for implementing simple genetic algorithms.
+test_files: []

data/test/test_population.rb

@@ -1,120 +0,0 @@
-require 'test/unit'
-require 'evopop'
-
-class PopulationTest < Test::Unit::TestCase
-  attr_accessor :population
-
-  def initialize_population
-    population = Population.new
-    population.population_size = 100
-    population.dna_len = 2
-    population.max_generations = 10000
-    population.initial_range_min = -10000.0
-    population.initial_range_max = 10000.0
-    population.mutation_range_min = -100.0
-    population.mutation_range_max = 100.0
-    population.mutation_num = 10
-    population.crossover_params = {:ordinal => (population.dna_len/2)}
-    population.crossover_function = Crossover.method(:one_point)
-    population.fitness_function = Proc.new { |dna|
-      Math.sin(dna[0]) + Math.cos(dna[1])
-    }
-    population.create
-    population
-  end
-
-  # Simple test to assure functions in the Population file are properly
-  # initializing the population parameters.
-  def test_initialize_population 
-    # Arrange and Act: Initialize the population
-    population = initialize_population
-
-    # Assert: Check that the given properties are initialized correctly.
-    assert_equal(population.candidates.length, population.population_size)
-    assert_equal(true, population.fitness_function.is_a?(Proc))
-
-    population.candidates.each { |c|
-      assert_equal(c.dna.length, population.dna_len)
-      assert_equal(true, c.dna[0] > population.initial_range_min)
-      assert_equal(true, c.dna[1] < population.initial_range_max)
-    }
-  end
-
-  # Simple test of the training function. Ensure that when training
-  # finishes the fitness of the ith element of the population is 
-  # less than or equal to the i-1th element of the population. I.e.
-  # fitness is becoming greater over the iteration of the popoulation.
-  def test_train
-    # Arrange: Initialize the population
-    population = initialize_population
-
-    # Act: Train the population based on default fitness function
-    population.train
-
-    # Assert: Training has sorted the population by fitness properly
-    population.candidates.length.times { |count|
-      assert_equal(population.candidates[count].fitness.nil?, false)
-      
-      if count > 0
-        assert_equal(true, population.candidates[count].fitness <= population.candidates[count-1].fitness)
-      end
-    }
-  end
-
-  # Simple test to ensure that only the exact number of candidates in the
-  # population are mutated.
-  def test_mutation
-    # Arrange: Initialize the population
-    population = initialize_population
-    old_candidates = Marshal.load(Marshal.dump(population.candidates))
-
-    # Act: Train the population based on default fitness function
-    population.mutate
-
-    # Assert: Only the specified number of candidates are being mutated
-    counter = 0
-    old_candidates.zip(population.candidates).each {|old_candidate, new_candidate|
-      if old_candidate.dna.to_s != new_candidate.dna.to_s
-        assert_equal(true, (old_candidate.dna[0] - new_candidate.dna[0]).abs <= population.mutation_range_max)
-        assert_equal(true, (old_candidate.dna[1] - new_candidate.dna[1]).abs <= population.mutation_range_max)
-        counter = counter + 1
-      end
-    }
-
-    assert_equal(population.mutation_num, counter)
-  end
-
-  # Simple
-  def test_one_point_crossover
-    # Arrange: Initialize the population
-    population = initialize_population
-    
-    # Act: Train and corssover the population a number of times
-    5.times {
-      population.train
-      population.crossover
-    }
-
-    # Assert: The initial average fitness is less than what occurs after 100 generations.
-    # This is to ensure that over generations the average fitness does indeed go up, given
-    # no mutation.
-    assert_equal(true, population.average_fitness[0] < population.average_fitness[population.average_fitness.length-1])
-  end
-  
-  def test_average_crossover
-    # Arrange: Initialize the population
-    population = initialize_population
-    population.crossover_function = Crossover.method(:average)
-
-    # Act: Train and corssover the population a number of times
-    100.times {
-      population.train
-      population.crossover
-    }
-
-    # Assert: The initial average fitness is less than what occurs after 100 generations.
-    # This is to ensure that over generations the average fitness does indeed go up, given
-    # no mutation.
-    assert_equal(true, population.average_fitness[0] < population.average_fitness[population.average_fitness.length-1])
-  end
-end