evopop 0.0.5 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 04d8cc00d713a77a686106e3be50d26d95889ec0
-  data.tar.gz: 0ee8bc2bca81622f24aa80184fa942fce901064d
+  metadata.gz: 5e6f9dc9b3385fbd06d69e3f4c8d062dab99b93b
+  data.tar.gz: e6ed6c011086a7901b5db7cad7c1e818827b7520
 SHA512:
-  metadata.gz: 2cae28bdfd5bc8d7e9aa431bfd2ff5765cbe7c5e4a7e2e1f28fb07269b8b42daf90e0554c772dfbe060735c3a278937bdf59752a192c1e623dacce55fd51679f
-  data.tar.gz: 6d418afe3bf3d4ec71e1e0f10d6877528fba2206759672d6299b27957e3d4f7e508740c5717fb13fab832933d4ebde93dbadf20849f52198950153f189ad9600
+  metadata.gz: 7cbcf3830e9c614853391008bce76aba3e55a74290cdc9059386af79a3681999fcc53c4bbda2e1c159a82d73300197f52fb2a9b9d45264e0976f84cb5f3a5c18
+  data.tar.gz: eb45100eee7f64bd1bfa03a2fbc3d050f852beaeb32c2e5f94ba6046773bbf06b0467ba19c26443c8018dbea391bce3ac8cbc3d7a3951da57e5a98fb0bac552d

data/README.md

@@ -1,7 +1,11 @@
+[![Build Status](https://travis-ci.org/elvinlucero/evopop.svg?branch=master)](https://travis-ci.org/elvinlucero/evopop)
+[![Code Climate](https://codeclimate.com/github/elvinlucero/evopop/badges/gpa.svg)](https://codeclimate.com/github/elvinlucero/evopop)
+
 Evopop
 ------------------------
 
-This is a library for implementing simple genetic algorithms to evolve over a fitness function.
+This is a library for implementing simple genetic algorithms to evolve
+over a fitness function.
 
 
 ``` ruby
@@ -9,7 +13,7 @@ This is a library for implementing simple genetic algorithms to evolve over a fi
 require 'evopop'
 
 # Initialize the population to be trained with good defaults.
-population = Population.new
+population = Evopop::Population.new
 population.population_size = 1000
 population.dna_len = 2
 population.max_generations = 1000
@@ -19,7 +23,7 @@ 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.crossover_function = Evopop::Crossover.method(:one_point)
 population.fitness_function = proc do |dna|
   Math.sin(dna[0]) + Math.cos(dna[1])
 end
@@ -36,7 +40,9 @@ 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}."
+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,22 @@
-# Public: Represents a candidate in the population. Candidates are abstracted
-# as a simple data structure which contains the DNA and fitness over the
-# fitness function.
-class Candidate
-  attr_accessor :dna, :fitness
+# frozen_string_literal: true
 
-  # Simple initialization of candidate object.
-  def initialize(dna = [])
-    @dna = dna
+module Evopop
+  # Public: Represents a candidate in the population.Evopop::Candidates are
+  # abstracted 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)
+      @dna = dna
+    end
+
+    def compose_parent_dna(c0, c1)
+      # 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 = c0.dna.take(ordinal)
+      # dna1_right = c1.dna.drop(ordinal)
+    end
   end
 end

data/lib/evopop/crossover.rb

@@ -1,101 +1,125 @@
-# 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
-    # 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
-    # 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(dna0_left + dna1_right),
-                Candidate.new(dna1_left + dna0_right)]
-
-    children
-  end
+# frozen_string_literal: true
 
-  # Perform two point crossover over a pair of candidates. Will output two
-  # children with genes spliced over the crossover points.
+module Evopop
+  # 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
+      # first candidate and the second chunk of the second candidate
+      dna_a_left = candidates[0].dna.take(ordinal)
+      dna_b_right = candidates[1].dna.drop(ordinal)
+
+      # Compose the dna of the second child from the first chunk of the
+      # first candidate and the second chunk of the second candidate
+      dna_b_left = candidates[1].dna.take(ordinal)
+      dna_a_right = candidates[0].dna.drop(ordinal)
+
+      min_range = candidates[0].dna.min_range
+      max_range = candidates[1].dna.max_range
+
+      min_mutation = candidates[1].dna.min_mutation
+      max_mutation = candidates[1].dna.max_mutation
+
+      dna_a = Evopop::Dna.create(min_range, max_range, min_mutation, max_mutation, dna_a_left + dna_b_right)
+      dna_b = Evopop::Dna.create(min_range, max_range, min_mutation, max_mutation, dna_b_left + dna_a_right)
+
+      # Initialize and assign DNA to children.
+      [
+        Evopop::Candidate.new(dna_a),
+        Evopop::Candidate.new(dna_b)
+      ]
+    end
 
-  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)
+    # Perform two point crossover over a pair of candidates. Will output two
+    # children with genes spliced over the crossover points.
 
-    # Initialize and assign the DNA of the children.
-    cdna0 = candidates[0].dna
-    cdna1 = candidates[1].dna
+    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)
 
-    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])
-    ]
+      # Initialize and assign the DNA of the children.
+      cdna_a = candidates[0].dna
+      cdna_b = candidates[1].dna
 
-    children
-  end
+      [
+        Evopop::Candidate.new(combine_on_ordinal(cdna_a, cdna_b, ordinals)),
+        Evopop::Candidate.new(combine_on_ordinal(cdna_b, cdna_a, ordinals))
+      ]
+    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)
+    def self.combine_on_ordinal(dna_a, dna_b, ordinals)
+      # TODO: Would this be better in dna.rb?
+      dna_a[0..ordinals[0]] + dna_b[(ordinals[0] + 1)..ordinals[1]] + dna_a[(ordinals[1] + 1)..dna_a.length - 1]
+    end
 
-    pdna0 = candidates[0].dna
-    pdna1 = candidates[1].dna
+    # 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)
 
-    dna_length = candidates[0].dna.length
+      pdna_a = candidates[0].dna
+      pdna_b = candidates[1].dna
 
-    cdna0 = []
-    cdna1 = []
+      dna_length = candidates[0].dna.length
 
-    old_ordinal = 0
-    synchronous = ordinals[0] == 0 ? false : true
+      cdna_a = []
+      cdna_b = []
 
-    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
+      old_ordinal = 0
+      synchronous = ordinals[0] == 0 ? false : true
 
-      synchronous = !synchronous
-      old_ordinal = i + 1
+      ordinals.each do |i|
+        n_ordinal = old_ordinal..i
 
-      next if ordinals.last != old_ordinal - 1
+        cdna_a, cdna_b = build_dna_by_synchronous(cdna_a, cdna_b, pdna_a, pdna_b, n_ordinal, synchronous)
 
-      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]
+        synchronous = !synchronous
+        next_ordinal = i + 1
+
+        next if ordinals.last != next_ordinal - 1
+
+        ordinal_range = next_ordinal..(dna_length - 1)
+        cdna_a, cdna_b = build_dna_by_synchronous(cdna_a, cdna_b, pdna_a, pdna_b, ordinal_range, synchronous)
       end
-    end
 
-    [Candidate.new(cdna0), Candidate.new(cdna1)]
-  end
+      [
+        Evopop::Candidate.new(cdna_a),
+        Evopop::Candidate.new(cdna_b)
+      ]
+    end
 
-  def self.average(candidates, _params)
-    child = Candidate.new
-    dna_length = candidates[0].dna.length
+    def self.build_dna_by_synchronous(cdna_a, cdna_b, pdna_a, pdna_b, ordinal_range, synchronous)
+      pdnas = [pdna_a, pdna_b]
+      pdnas.reverse! unless synchronous
+      cdna_a += pdnas[0][ordinal_range]
+      cdna_b += pdnas[1][ordinal_range]
 
-    (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
+      [cdna_a, cdna_b]
     end
 
-    [child]
+    def self.average(candidates, _params)
+      new_dna = Evopop::Dna.new(
+        candidates[0].dna.min_range,
+        candidates[0].dna.max_range,
+        candidates[0].dna.min_mutation,
+        candidates[0].dna.max_mutation,
+        candidates[0].dna.length
+      )
+      new_dna.dna = []
+      (0...candidates[0].dna.length).each do |j|
+        # Initialize the dna of the child with the average of the parents' dna.
+        new_dna.dna << (candidates[0].dna[j] + candidates[1].dna[j]) / 2.0
+      end
+
+      [Evopop::Candidate.new(new_dna)]
+    end
   end
 end

data/lib/evopop/dna.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Evopop
+  # Represents a Dna structure, like an array of floating point values
+  class Dna
+    attr_accessor :dna, :dna_len, :min_range, :max_range, :min_mutation, :max_mutation
+
+    def initialize(min_range, max_range, min_mutation, max_mutation, dna_len)
+      # TODO: Extract these to a DnaProperties class or something so we don't
+      # have to couple parameter passsing so much.
+      @min_range = min_range
+      @max_range = max_range
+      @min_mutation = min_mutation
+      @max_mutation = max_mutation
+      @dna = []
+      @dna_len = dna_len
+
+      dna_len_range.each do
+        @dna << random_dna_val
+      end
+    end
+
+    def self.create(min_range, max_range, min_mutation, max_mutation, dna)
+      new_dna = new(min_range, max_range, min_mutation, max_mutation, dna.size)
+      new_dna.dna = dna
+      new_dna
+    end
+
+    def dna_len_range
+      0...@dna_len
+    end
+
+    def random_dna_val
+      Random.rand(@min_range...@max_range)
+    end
+
+    def random_mutation_val
+      Random.rand(@min_mutation...@max_mutation)
+    end
+
+    def mutate(i)
+      @dna[i] += [random_mutation_val, -1 * random_mutation_val].sample
+    end
+
+    def length
+      @dna.length
+    end
+
+    def take(num)
+      @dna.take(num)
+    end
+
+    def drop(ordinal)
+      @dna.drop(ordinal)
+    end
+
+    def [](key)
+      @dna[key]
+    end
+
+    def []=(key, value)
+      @dna[key] = value
+    end
+
+    def ==(other)
+      @dna == other.dna
+    end
+
+    def to_s
+      @dna.to_s
+    end
+  end
+end

data/lib/evopop/population.rb

@@ -1,110 +1,108 @@
-
-# Represents the population that is being trained. Has various methods
-# relevant to training.
-#
-#
-# Examples
-#   population = Population.new
-#   ... initialize population with parameters ...
-#   population.train
-#   population.crossover
-#   population.mutate
-class Population
-  attr_accessor :candidates, :population_size, :max_generations, :crossover_function, :crossover_params, :initial_range_min, :initial_range_max, :mutation_range_min, :mutation_range_max, :mutation_num, :fitness_function, :dna_len, :average_fitness
-
-  # Initializes the attributes with default values. This is not guaranteed
-  # to reach maxima.
-  def initialize
-    @average_fitness = []
-    @population_size = 100
-    @max_generations = 100
-    @initial_range_min = -100
-    @initial_range_max = 100
-    @mutation_range_min = -10
-    @mutation_range_max = 10
-    @mutation_num = (0.10 * @population_size).to_i
-    @dna_len = 1
-    @crossover_params = { ordinal: (@dna_len / 2) }
-
-    @crossover_function = Crossover.method(:one_point)
-    @fitness_function = proc do |dna|
-      Math.sin(dna[0])
-    end
-
-    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) do
-      candidate = Candidate.new
-      (0...@dna_len).each do
-        candidate.dna << Random.rand(@initial_range_min...@initial_range_max)
+# frozen_string_literal: true
+
+module Evopop
+  # Represents the population that is being trained. Has various methods
+  # relevant to training.
+  #
+  #
+  # Examples
+  #   population = Evopop::Population.new
+  #   ... initialize population with parameters ...
+  #   population.train
+  #   population.crossover
+  #   population.mutate
+  class Population
+    attr_accessor :candidates, :population_size, :max_generations,
+                  :crossover_function, :crossover_params, :initial_range_min,
+                  :initial_range_max, :mutation_range_min, :mutation_range_max,
+                  :mutation_num, :fitness_function, :dna_len, :average_fitness
+
+    # Initializes the attributes with default values. This is not guaranteed
+    # to reach maxima.
+    def initialize
+      Evopop.config.instance_variables.each do |iv|
+        instance_variable_set(
+          iv,
+          Evopop.config.instance_variable_get(iv)
+        )
       end
-      candidate
+      create
+      self
     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 do |c|
-      c.fitness = fitness_function.call(c.dna)
-      average_fitness += + c.fitness
+    # Creates a new set of population. Should be called after all the
+    # parameters have been set to the attributes.
+    def create
+      @candidates = Array.new(@population_size) do
+        dna = Evopop::Dna.new(
+          @initial_range_min,
+          @initial_range_max,
+          @mutation_range_min,
+          @mutation_range_max,
+          @dna_len
+        )
+        candidate = Evopop::Candidate.new(dna)
+        candidate
+      end
     end
 
-    average_fitness /= @population_size
-
-    @average_fitness << average_fitness
-
-    @candidates = @candidates.sort_by(&:fitness)
-    @candidates = @candidates.reverse
-  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 do |c|
+        c.fitness = fitness_function.call(c.dna)
+        average_fitness += + c.fitness
+      end
 
-  # Performs simple mechanism of crossover - in this case picks two
-  # 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)
+      average_fitness /= @population_size
 
-    new_generation = []
+      @average_fitness << average_fitness
 
-    (0...@population_size).each do
-      # For each of the top 75% of the population take 2
-      couple = @candidates.sample(2)
-      params = @crossover_params
+      @candidates = @candidates.sort_by(&:fitness)
+      @candidates = @candidates.reverse
+    end
 
-      children = @crossover_function.call(couple, params)
+    # Performs simple mechanism of crossover - in this case picks two
+    # 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
+      new_generation = []
+
+      # For all the top candidates, take the top 2 and crossover
+      (0...@population_size).each do
+        children = @crossover_function.call(top_candidates.sample(2), @crossover_params)
+        new_generation += children
+
+        if new_generation.length >= population_size
+          new_generation = new_generation.take(population_size)
+          break
+        end
+      end
 
-      new_generation += children
+      @candidates = new_generation
+    end
 
-      # When we go above set population_size, take the first population_size
-      # candidates, ignore the rest.
-      if new_generation.length >= population_size
-        new_generation = new_generation.take(population_size)
-        break
+    # 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.each do |c|
+        c.dna.dna_len_range.each do |i|
+          c.dna.mutate(i)
+        end
       end
     end
 
-    @candidates = new_generation
-  end
+    private
 
-  # 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(mutation_num)
+    def top_candidates
+      @candidates.take((@population_size * 0.75).to_i)
+    end
 
-    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
+    def mutated_candidates
+      @candidates.sample(@mutation_num)
     end
   end
 end

data/lib/evopop.rb

@@ -1,7 +1,48 @@
+# frozen_string_literal: true
+
 require 'evopop/population'
 require 'evopop/candidate'
 require 'evopop/crossover'
+require 'evopop/dna'
 
 # Toplevel class for evopop project
 module Evopop
+  class << self
+    attr_accessor :config
+  end
+
+  def self.popconfig
+    @config ||= PopulationConfig.new
+    yield(@config)
+  end
+
+  # Defines the configuration to be available to all of Evopop
+  class PopulationConfig
+    attr_accessor :average_fitness, :population_size, :max_generations,
+                  :initial_range_min, :initial_range_max, :mutation_range_min,
+                  :mutation_range_max, :mutation_num, :dna_len,
+                  :crossover_params, :crossover_function, :fitness_function
+
+    def initialize
+      @average_fitness = []
+      @population_size = 100
+      @max_generations = 100
+      @initial_range_min = -100
+      @initial_range_max = 100
+      @mutation_range_min = -10
+      @mutation_range_max = 10
+      @mutation_num = (0.10 * @population_size).to_i
+      @dna_len = 1
+      @crossover_params = { ordinal: (@dna_len / 2) }
+
+      @crossover_function = Evopop::Crossover.method(:one_point)
+      @fitness_function = proc do |dna|
+        Math.sin(dna[0])
+      end
+    end
+  end
+end
+
+Evopop.popconfig do |config|
+  # Configure evopop here.
 end

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: evopop
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.1.0
 platform: ruby
 authors:
 - Elvin Lucero
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-24 00:00:00.000000000 Z
+date: 2017-07-08 00:00:00.000000000 Z
 dependencies: []
 description: A simple library for implementing simple genetic algorithms.
-email: elvin+evopop@pluots.io
+email: elvin+evopop@1au.io
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -21,6 +21,7 @@ files:
 - lib/evopop.rb
 - lib/evopop/candidate.rb
 - lib/evopop/crossover.rb
+- lib/evopop/dna.rb
 - lib/evopop/population.rb
 homepage: https://rubygems.org/gems/evopop
 licenses:
@@ -42,7 +43,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.6.12
 signing_key: 
 specification_version: 4
 summary: A simple library for implementing simple genetic algorithms.