evolvable 0.1.3 → 1.0.0

data/lib/evolvable/goal/maximize.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Evolvable::Goal
+  class Maximize
+    include Evolvable::Goal
+
+    def value
+      @value ||= Float::INFINITY
+    end
+
+    def evaluate(instance)
+      instance.value
+    end
+
+    def met?(instance)
+      instance.value >= value
+    end
+  end
+end

data/lib/evolvable/goal/minimize.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Evolvable::Goal
+  class Minimize
+    include Evolvable::Goal
+
+    def value
+      @value ||= -Float::INFINITY
+    end
+
+    def evaluate(instance)
+      -instance.value
+    end
+
+    def met?(instance)
+      instance.value <= value
+    end
+  end
+end

data/lib/evolvable/mutation.rb

@@ -1,64 +1,42 @@
+# frozen_string_literal: true
+
 module Evolvable
   class Mutation
     extend Forwardable
 
-    def initialize(rate: 0.03)
-      @rate = rate
+    def initialize(probability: nil, rate: nil)
+      @probability = probability || (rate ? 1 : 0.03)
+      @rate = rate || 0
     end
 
-    attr_accessor :rate
-
-    def_delegators :@evolvable_class,
-                   :evolvable_genes_count,
-                   :evolvable_gene_pool_size,
-                   :evolvable_random_genes
+    attr_accessor :probability,
+                  :rate
 
-    def call!(objects)
-      @evolvable_class = objects.first.class
-      mutations_count = find_mutations_count(objects)
-      return if mutations_count.zero?
+    def call(population)
+      return population if probability.zero?
 
-      mutant_genes = generate_mutant_genes(mutations_count)
-      object_mutations_count = mutations_count / objects.count
-      object_mutations_count = 1 if object_mutations_count.zero?
-
-      mutant_genes.each_slice(object_mutations_count).with_index do |m_genes, index|
-        object = objects[index] || objects.sample
-        genes = object.genes
-        genes.merge!(m_genes.to_h)
-        rm_genes_count = genes.count - evolvable_genes_count
-        genes.keys.sample(rm_genes_count).each { |key| genes.delete(key) }
+      population.instances.each do |instance|
+        mutate_instance(instance) if rand <= probability
       end
-    end
-
-    def inspect
-      "#<#{self.class.name} #{as_json.map { |a| a.join(': ') }.join(', ')} >"
-    end
-
-    def as_json
-      { type: self.class.name,
-        rate: @rate }
+      population
     end
 
     private
 
-    def find_mutations_count(objects)
-      return 0 if @rate.zero?
+    def mutate_instance(instance)
+      genes_count = instance.genes.count
+      return if genes_count.zero?
 
-      count = (objects.count * evolvable_genes_count * @rate)
-      return count.to_i if count >= 1
+      return mutate_gene(instance, rand(genes_count)) if rate.zero?
 
-      rand <= count ? 1 : 0
+      genes_count.times { |index| mutate_gene(instance, index) if rand <= rate }
     end
 
-    def generate_mutant_genes(mutations_count)
-      gene_pool_size = evolvable_gene_pool_size
-      mutant_genes = []
-      while mutant_genes.count < mutations_count
-        genes_count = [gene_pool_size, mutations_count - mutant_genes.count].min
-        mutant_genes.concat evolvable_random_genes(genes_count).to_a
-      end
-      mutant_genes
+    def mutate_gene(instance, gene_index)
+      gene = instance.genes[gene_index]
+      mutant_gene = gene.class.new
+      mutant_gene.key = gene.key
+      instance.genes[gene_index] = mutant_gene
     end
   end
 end

data/lib/evolvable/point_crossover.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Evolvable
+  class PointCrossover
+    def initialize(points_count: 1)
+      @points_count = points_count
+    end
+
+    attr_accessor :points_count
+
+    def call(population)
+      population.instances = initialize_offspring(population)
+      population
+    end
+
+    private
+
+    def initialize_offspring(population)
+      parent_genes = population.instances.map!(&:genes)
+      parent_gene_couples = parent_genes.combination(2).cycle
+      offspring = []
+      population_index = 0
+      loop do
+        genes_1, genes_2 = parent_gene_couples.next
+        crossover_genes(genes_1, genes_2).each do |genes|
+          offspring << population.new_instance(genes: genes, population_index: population_index)
+          population_index += 1
+          return offspring if population_index == population.size
+        end
+      end
+    end
+
+    def crossover_genes(genes_1, genes_2)
+      offspring_genes = [[], []]
+      generate_ranges(genes_1.length).each do |range|
+        offspring_genes.reverse!
+        offspring_genes[0][range] = genes_1[range]
+        offspring_genes[1][range] = genes_2[range]
+      end
+      offspring_genes
+    end
+
+    def generate_ranges(genes_count)
+      current_point = rand(genes_count)
+      range_slices = [0...current_point]
+      (points_count - 1).times do
+        new_point = rand(current_point...genes_count)
+        break if new_point.nil?
+
+        range_slices << (current_point...new_point)
+        current_point = new_point
+      end
+      range_slices << (current_point..-1)
+      range_slices
+    end
+  end
+end

data/lib/evolvable/population.rb

@@ -4,115 +4,94 @@ module Evolvable
   class Population
     extend Forwardable
 
-    def initialize(evolvable_class:,
-                   size: 20,
-                   selection_count: 2,
-                   crossover: Crossover.new,
-                   mutation: Mutation.new,
-                   generation_count: 0,
-                   log_progress: false,
-                   objects: [])
+    def initialize(id: nil,
+                   evolvable_class:,
+                   name: nil,
+                   size: 40,
+                   evolutions_count: 0,
+                   gene_space: nil,
+                   evolution: Evolution.new,
+                   evaluation: Evaluation.new,
+                   instances: [])
+      @id = id
       @evolvable_class = evolvable_class
+      @name = name
       @size = size
-      @selection_count = selection_count
-      @crossover = crossover
-      @mutation = mutation
-      @generation_count = generation_count
-      @log_progress = log_progress
-      assign_objects(objects)
+      @evolutions_count = evolutions_count
+      @gene_space = initialize_gene_space(gene_space)
+      @evolution = evolution
+      @evaluation = evaluation || Evaluation.new
+      initialize_instances(instances)
     end
 
-    attr_accessor :evolvable_class,
+    attr_accessor :id,
+                  :evolvable_class,
+                  :name,
                   :size,
-                  :selection_count,
-                  :crossover,
-                  :mutation,
-                  :generation_count,
-                  :log_progress,
-                  :objects
-
-    def_delegators :@evolvable_class,
-                   :evolvable_evaluate!,
-                   :evolvable_initialize,
-                   :evolvable_random_genes,
-                   :evolvable_before_evolution,
-                   :evolvable_after_select,
-                   :evolvable_after_evolution
-
-    def evolve!(generations_count: 1, fitness_goal: nil)
-      @fitness_goal = fitness_goal
-      generations_count.times do
-        @generation_count += 1
-        evolvable_before_evolution(self)
-        evaluate_objects!
-        log_evolvable_progress if log_progress
-        break if fitness_goal_met?
-
-        select_objects!
-        evolvable_after_select(self)
-        crossover_objects!
-        mutate_objects!
-        evolvable_after_evolution(self)
-      end
-    end
-
-    def strongest_object
-      objects.max_by(&:fitness)
-    end
-
-    def evaluate_objects!
-      evolvable_evaluate!(@objects)
-      if @fitness_goal
-        @objects.sort_by! { |i| -(i.fitness - @fitness_goal).abs }
-      else
-        @objects.sort_by!(&:fitness)
+                  :evolutions_count,
+                  :gene_space,
+                  :evolution,
+                  :evaluation,
+                  :instances
+
+    def_delegators :evolvable_class,
+                   :before_evaluation,
+                   :before_evolution,
+                   :after_evolution
+
+    def_delegators :evolution,
+                   :selection,
+                   :selection=,
+                   :crossover,
+                   :crossover=,
+                   :mutation,
+                   :mutation=
+
+    def_delegators :evaluation,
+                   :goal,
+                   :goal=
+
+    def evolve(count: Float::INFINITY, goal_value: nil)
+      goal.value = goal_value if goal_value
+      (1..count).each do
+        before_evaluation(self)
+        evaluation.call(self)
+        before_evolution(self)
+        break if met_goal?
+
+        evolution.call(self)
+        self.evolutions_count += 1
+        after_evolution(self)
       end
     end
 
-    def log_evolvable_progress
-      @objects.last.evolvable_progress
+    def best_instance
+      evaluation.best_instance(self)
     end
 
-    def fitness_goal_met?
-      @fitness_goal && @objects.last.fitness >= @fitness_goal
+    def met_goal?
+      evaluation.met_goal?(self)
     end
 
-    def select_objects!
-      @objects.slice!(0..-1 - @selection_count)
+    def new_instance(genes: [], population_index: nil)
+      evolvable_class.new_instance(population: self,
+                                   genes: genes,
+                                   population_index: population_index)
     end
 
-    def crossover_objects!
-      parent_genes = @objects.map(&:genes)
-      offspring_genes = @crossover.call(parent_genes, @size)
-      @objects = offspring_genes.map.with_index do |genes, i|
-        evolvable_initialize(genes, self, i)
-      end
-    end
-
-    def mutate_objects!
-      @mutation.call!(@objects)
-    end
+    private
 
-    def inspect
-      "#<#{self.class.name} #{as_json} >"
-    end
+    def initialize_gene_space(gene_space)
+      return GeneSpace.build(gene_space) if gene_space
 
-    def as_json
-      { evolvable_class: @evolvable_class.name,
-        size: @size,
-        selection_count: @selection_count,
-        crossover: @crossover.as_json,
-        mutation: @mutation.as_json,
-        generation_count: @generation_count }
+      evolvable_class.new_gene_space
     end
 
-    private
-
-    def assign_objects(objects)
-      @objects = objects || []
-      (@size - objects.count).times do |n|
-        genes = evolvable_random_genes
-        @objects << evolvable_initialize(genes, self, n)
+    def initialize_instances(instances)
+      @instances = instances || []
+      (@size - instances.count).times do |n|
+        genes = gene_space.new_genes
+        @instances << new_instance(genes: genes, population_index: n)
       end
     end
   end

data/lib/evolvable/selection.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Evolvable
+  class Selection
+    extend Forwardable
+
+    def initialize(size: 2)
+      @size = size
+    end
+
+    attr_accessor :size
+
+    def call(population)
+      population.instances.slice!(0..-1 - @size)
+      population
+    end
+  end
+end

data/lib/evolvable/uniform_crossover.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Evolvable
+  class UniformCrossover
+    def call(population)
+      population.instances = initialize_offspring(population)
+      population
+    end
+
+    private
+
+    def initialize_offspring(population)
+      parent_genes = population.instances.map!(&:genes)
+      parent_gene_couples = parent_genes.combination(2).cycle
+      Array.new(population.size) do |index|
+        genes_1, genes_2 = parent_gene_couples.next
+        genes = genes_1.zip(genes_2).map!(&:sample)
+        population.new_instance(genes: genes, population_index: index)
+      end
+    end
+  end
+end

data/lib/evolvable/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Evolvable
-  VERSION = '0.1.3'
+  VERSION = '1.0.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: evolvable
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 1.0.0
 platform: ruby
 authors:
 - Matt Ruzicka
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-03-11 00:00:00.000000000 Z
+date: 2020-09-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -67,13 +67,24 @@ files:
 - bin/console
 - bin/setup
 - evolvable.gemspec
+- examples/evolvable_string.rb
+- examples/evolvable_string/char_gene.rb
 - lib/evolvable.rb
-- lib/evolvable/crossover.rb
-- lib/evolvable/errors/not_implemented.rb
-- lib/evolvable/helper_methods.rb
-- lib/evolvable/hooks.rb
+- lib/evolvable/error/undefined_method.rb
+- lib/evolvable/evaluation.rb
+- lib/evolvable/evolution.rb
+- lib/evolvable/gene.rb
+- lib/evolvable/gene_crossover.rb
+- lib/evolvable/gene_space.rb
+- lib/evolvable/goal.rb
+- lib/evolvable/goal/equalize.rb
+- lib/evolvable/goal/maximize.rb
+- lib/evolvable/goal/minimize.rb
 - lib/evolvable/mutation.rb
+- lib/evolvable/point_crossover.rb
 - lib/evolvable/population.rb
+- lib/evolvable/selection.rb
+- lib/evolvable/uniform_crossover.rb
 - lib/evolvable/version.rb
 homepage: https://github.com/mattruzicka/evolvable
 licenses:
@@ -97,7 +108,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Add evolutionary behavior to any Ruby object