gimuby 0.7.2

data/lib/gimuby/genetic/population/population.rb

@@ -0,0 +1,97 @@
+require 'gimuby/dependencies'
+require 'gimuby/genetic/population/pick_strategy/random_wheel_pick_strategy'
+require 'gimuby/genetic/population/replace_strategy/replace_worst_replace_strategy'
+
+class Population
+
+  def initialize(solutions = nil)
+    if solutions.nil?
+      @solutions = []
+    else
+      @solutions = solutions
+    end
+    @pick_strategy ||= RandomWheelPickStrategy.new
+    @replace_strategy ||= ReplaceWorstReplaceStrategy.new
+
+    trigger(:on_population_init)
+  end
+
+  attr_reader :solutions
+  attr_accessor :pick_strategy
+  attr_accessor :selection_rate
+  attr_accessor :replace_strategy
+
+  # Run a step of genetic algorithm: reproduction + mutation
+  def generation_step
+    reproduce
+    @solutions.each do |solution|
+      solution.mutate
+    end
+    trigger(:on_population_generation_step)
+  end
+
+  # Replace part of the population (used by {Archipelago})
+  # @internal
+  def replace(solutions)
+    @solutions = @replace_strategy.replace(self, solutions)
+  end
+
+  # Simply pick some solutions and make them reproduce
+  # @internal
+  def reproduce
+    @solutions = @replace_strategy.replace(self)
+  end
+
+  # Pick some solutions
+  # @internal
+  def pick
+    @pick_strategy.pick(self)
+  end
+
+  # Add a solution
+  # @param solution [Solution]
+  def add_solution(solution)
+    @solutions.push solution
+  end
+
+  def get_population_size
+    @solutions.size
+  end
+
+  # Can be overridden
+  def get_fitness(solution)
+    solution.get_fitness
+  end
+
+  def get_average_fitness
+    sum = 0
+    @solutions.each do |solution|
+      sum += solution.get_fitness
+    end
+    # Beware of that division by 0
+    sum / @solutions.length
+  end
+
+  def get_best_fitness
+    best_solution = get_best_solution
+    best_solution.get_fitness
+  end
+
+  def get_best_solution
+    best_solution = @solutions.min_by do |solution|
+      solution.get_fitness
+    end
+    best_solution
+  end
+
+  protected
+
+  def trigger(event_type)
+    event_data = {:population => self}
+    get_event_manager.trigger_event(event_type, event_data)
+  end
+
+  def get_event_manager
+    $dependencies.event_manager
+  end
+end

data/lib/gimuby/genetic/population/replace_strategy/replace_strategy.rb

@@ -0,0 +1,9 @@
+class ReplaceStrategy
+
+  # Replace solution within the population
+  # This function should call population.pick if selected is nil
+  def replace(population, selected = nil)
+    raise NotImplementedError
+  end
+
+end

data/lib/gimuby/genetic/population/replace_strategy/replace_worst_replace_strategy.rb

@@ -0,0 +1,52 @@
+require 'gimuby/genetic/population/replace_strategy/replace_strategy'
+
+class ReplaceWorstReplaceStrategy < ReplaceStrategy
+
+  def initialize
+    @replace_proportion = 50.to_f / 100.to_f
+  end
+
+  attr_accessor :replace_proportion
+
+  def replace(population, selected = nil)
+    solutions = population.solutions.clone
+
+    wished_length = solutions.length
+    solutions.sort! do |x, y|
+      x_fitness = population.get_fitness(x)
+      y_fitness = population.get_fitness(y)
+      x_fitness <=> y_fitness
+    end
+    if selected.nil?
+      selected = population.pick
+    end
+    number_to_remove = (wished_length * @replace_proportion).floor
+    if number_to_remove == wished_length
+      number_to_remove -= 1
+    end
+    solutions.slice!(-number_to_remove, number_to_remove)
+
+    while solutions.length < wished_length
+      begin
+        random_index1 = rand(selected.length)
+        random_index2 = rand(selected.length)
+      end while ((random_index1 == random_index2) && (selected.length != 1))
+      new_solutions = reproduce(selected[random_index1],
+                                selected[random_index2])
+      new_solutions.each do |new_solution|
+        solutions.push(new_solution)
+      end
+    end
+
+    solutions.slice!(wished_length) # we could have one that should be dropped
+    solutions
+  end
+
+  protected
+
+  def reproduce(solution1, solution2)
+    solution1.reproduce(solution1, solution2)
+  end
+
+
+end

data/lib/gimuby/genetic/population/replace_strategy/uniform_replace_strategy.rb

@@ -0,0 +1,48 @@
+require 'gimuby/genetic/population/replace_strategy/replace_strategy'
+
+class UniformReplaceStrategy < ReplaceStrategy
+
+  def initialize
+    @replace_proportion = 50.to_f / 100.to_f
+  end
+
+  attr_accessor :replace_proportion
+
+  def replace(population, selected = nil)
+    solutions = population.solutions.clone
+
+    wished_length = solutions.length
+    solutions.shuffle!
+    if selected.nil?
+      selected = population.pick
+    end
+    number_to_remove = (wished_length * @replace_proportion).floor
+    if number_to_remove == wished_length
+      number_to_remove -= 1
+    end
+    solutions.slice!(-number_to_remove, number_to_remove)
+
+    while solutions.length < wished_length
+      begin
+        random_index1 = rand(selected.length)
+        random_index2 = rand(selected.length)
+      end while ((random_index1 == random_index2) && (selected.length != 1))
+      new_solutions = reproduce(selected[random_index1],
+                                selected[random_index2])
+      new_solutions.each do |new_solution|
+        solutions.push(new_solution)
+      end
+    end
+
+    solutions.slice!(wished_length) # we could have one that should be dropped
+    solutions
+  end
+
+  protected
+
+  def reproduce(solution1, solution2)
+    solution1.reproduce(solution1, solution2)
+  end
+
+
+end

data/lib/gimuby/genetic/solution/check_strategy/check_strategy.rb

@@ -0,0 +1,8 @@
+
+class CheckStrategy
+
+  def check(solution_representation)
+    raise NotImplementedError
+  end
+
+end

data/lib/gimuby/genetic/solution/check_strategy/permutation_check_strategy.rb

@@ -0,0 +1,37 @@
+require 'gimuby/genetic/solution/check_strategy/check_strategy'
+
+#
+# Permutation goes represented as permutation from [0, ... l] indexes
+class PermutationCheckStrategy < CheckStrategy
+
+  def check(solution_representation)
+    permutation = solution_representation
+    expected_elements = *(0..permutation.length - 1)
+    duplicate = []
+    missing = []
+    expected_elements.each do |element|
+      match = permutation.select do |concreteElement|
+        concreteElement == element
+      end
+      case match.length <=> 1
+        when -1 then
+          missing.push(element)
+        when 1 then
+          duplicate.push(element)
+        else
+          # do nothing
+      end
+    end
+    missing.shuffle!
+    duplicate.each do |to_remove|
+      to_insert = missing.pop()
+      ind = permutation.index(to_remove)
+      permutation[ind] = to_insert
+    end
+    unless missing.empty?
+      solution_representation = check(solution_representation)
+    end
+    solution_representation
+  end
+
+end

data/lib/gimuby/genetic/solution/check_strategy/solution_space_check_strategy.rb

@@ -0,0 +1,74 @@
+require 'gimuby/genetic/solution/check_strategy/check_strategy'
+
+# Permutation goes represented as permutation from [0, ... l] indexes
+class SolutionSpaceCheckStrategy < CheckStrategy
+
+  def initialize
+    @default_min = nil
+    @default_max = nil
+    @mins = {}
+    @maxs = {}
+  end
+
+  def check(solution_representation)
+    solution_representation.each_index do |index|
+      value = solution_representation[index]
+
+      if value.class == Array
+        value = check(value)
+      else
+        min = get_min(index)
+        unless min.nil?
+          if value < min
+            value = min
+          end
+        end
+
+        max = get_max(index)
+        unless max.nil?
+          if value > max
+            value = max
+          end
+        end
+      end
+
+      solution_representation[index] = value
+    end
+
+    solution_representation
+  end
+
+  def set_min(min, index = nil)
+    if index.nil?
+      @default_min = min
+    else
+      @mins[index] = min
+    end
+  end
+
+  def set_max(max, index = nil)
+    if index.nil?
+      @default_max = max
+    else
+      @maxs[index] = max
+    end
+  end
+
+  protected
+
+  def get_min(index)
+    min = @default_min
+    if @mins.has_key?(index)
+      min = @mins[index]
+    end
+    min
+  end
+
+  def get_max(index)
+    max = @default_max
+    if @maxs.has_key?(index)
+      max = @maxs[index]
+    end
+    max
+  end
+end

data/lib/gimuby/genetic/solution/function_based_solution.rb

@@ -0,0 +1,64 @@
+require 'gimuby/genetic/solution/solution'
+require 'gimuby/genetic/solution/check_strategy/solution_space_check_strategy'
+require 'gimuby/genetic/solution/new_generation_strategy/combined_new_generation_strategy'
+require 'gimuby/genetic/solution/new_generation_strategy/parent_range_new_generation_strategy'
+require 'gimuby/genetic/solution/new_generation_strategy/cross_over_new_generation_strategy'
+require 'gimuby/genetic/solution/new_generation_strategy/average_new_generation_strategy'
+require 'gimuby/genetic/solution/mutation_strategy/solution_space_mutation_strategy'
+
+class FunctionBasedSolution < Solution
+
+  def initialize(x_values = nil)
+    super(x_values)
+
+    @check_strategy = SolutionSpaceCheckStrategy.new
+    @check_strategy.set_min(get_x_value_min)
+    @check_strategy.set_max(get_x_value_max)
+
+    @new_generation_strategy = CombinedNewGenerationStrategy.new
+    @new_generation_strategy.add_strategy(ParentRangeNewGenerationStrategy.new)
+    @new_generation_strategy.add_strategy(CrossOverNewGenerationStrategy.new)
+    @new_generation_strategy.add_strategy(AverageNewGenerationStrategy.new)
+
+    @mutation_strategy = SolutionSpaceMutationStrategy.new
+    @mutation_strategy.set_min(get_x_value_min)
+    @mutation_strategy.set_max(get_x_value_max)
+  end
+
+  def evaluate
+    raise NotImplementedError
+  end
+
+  def get_solution_representation
+    @x_values.clone
+  end
+
+  def set_solution_representation(x_values)
+    @x_values = x_values.clone
+  end
+
+  protected
+
+  def init_representation
+    @x_values = []
+    dimension = get_dimension_number
+    dimension.times do |_|
+      range = get_x_value_max - get_x_value_min
+      x_value = (rand() * range) + get_x_value_min
+      @x_values.push(x_value)
+    end
+  end
+
+  def get_x_value_min
+    raise NotImplementedError
+  end
+
+  def get_x_value_max
+    raise NotImplementedError
+  end
+
+  def get_dimension_number
+    raise NotImplementedError
+  end
+
+end

data/lib/gimuby/genetic/solution/mutation_strategy/mutation_strategy.rb

@@ -0,0 +1,22 @@
+
+
+class MutationStrategy
+
+  def initialize(mutation_rate = 0.01)
+    @mutation_rate = mutation_rate
+  end
+
+  attr_accessor :mutation_rate
+
+  def mutate(solution)
+    if rand < @mutation_rate
+      perform_mutation(solution)
+      solution.reset_fitness_state
+    end
+  end
+
+  def perform_mutation(solution)
+    raise NotImplementedError
+  end
+
+end

data/lib/gimuby/genetic/solution/mutation_strategy/permutation_mutation_strategy.rb

@@ -0,0 +1,17 @@
+require 'gimuby/genetic/solution/mutation_strategy/mutation_strategy'
+
+class PermutationMutationStrategy < MutationStrategy
+
+  def perform_mutation(solution)
+    permutation = solution.get_solution_representation
+    begin
+      index1 = rand(permutation.length)
+      index2 = rand(permutation.length)
+    end while index1 == index2
+    tmp = permutation[index1]
+    permutation[index1] = permutation[index2]
+    permutation[index2] = tmp
+    solution.set_solution_representation(permutation)
+  end
+
+end

data/lib/gimuby/genetic/solution/mutation_strategy/solution_space_mutation_strategy.rb

@@ -0,0 +1,69 @@
+require 'gimuby/genetic/solution/mutation_strategy/mutation_strategy'
+
+class SolutionSpaceMutationStrategy < MutationStrategy
+
+  def initialize(mutation_rate = 0.01)
+    super(mutation_rate)
+    @default_min = nil
+    @default_max = nil
+    @mins = {}
+    @maxs = {}
+  end
+
+  def perform_mutation(solution)
+    x_values = solution.get_solution_representation
+    x_values = perform_mutation_from_representation(x_values)
+    solution.set_solution_representation(x_values)
+  end
+
+  def set_min(min, index = nil)
+    if index.nil?
+      @default_min = min
+    else
+      @mins[index] = min
+    end
+  end
+
+  def set_max(max, index = nil)
+    if index.nil?
+      @default_max = max
+    else
+      @maxs[index] = max
+    end
+  end
+
+  protected
+
+  def perform_mutation_from_representation(x_values)
+    index = rand(x_values.length)
+
+    x_value = x_values[index]
+    if x_value.class == Array
+      x_value = perform_mutation_from_representation(x_value)
+    else
+      min = get_min(index)
+      max = get_max(index)
+      range = max - min
+      x_value = rand() * range + min
+    end
+    x_values[index] = x_value
+    x_values
+  end
+
+  def get_min(index)
+    min = @default_min
+    if @mins.has_key?(index)
+      min = @mins[index]
+    end
+    min
+  end
+
+  def get_max(index)
+    max = @default_max
+    if @maxs.has_key?(index)
+      max = @maxs[index]
+    end
+    max
+  end
+
+end