gimuby 0.7.2

data/lib/gimuby/genetic/solution/new_generation_strategy/average_new_generation_strategy.rb

@@ -0,0 +1,41 @@
+require 'gimuby/genetic/solution/new_generation_strategy/new_generation_strategy'
+
+class AverageNewGenerationStrategy < NewGenerationStrategy
+
+  # @param best_weight {Float} The weight given to the best solution
+  def initialize(best_weight = 1.0)
+    @best_weight = best_weight
+  end
+
+  def reproduce(solution1, solution2)
+    weight1 = 1.0
+    weight2 = 1.0
+    if solution1.get_fitness < solution2.get_fitness
+      weight1 = @best_weight
+    else
+      weight2 = @best_weight
+    end
+    x_values1 = solution1.get_solution_representation
+    x_values2 = solution2.get_solution_representation
+    reproduce_from_representation(x_values1, x_values2, weight1, weight2)
+  end
+
+  protected
+
+  def reproduce_from_representation(x_values1, x_values2, weight1, weight2)
+    x_values = []
+    x_values1.each_index do |i|
+      x_value1 = x_values1[i]
+      x_value2 = x_values2[i]
+      if x_value1.class == Array
+        x_value = reproduce_from_representation(x_value1, x_value2, weight1, weight2).pop()
+      else
+        x_value = x_value1 * weight1 + x_value2 * weight2
+        x_value /= (weight1 + weight2)
+      end
+      x_values.push(x_value)
+    end
+    [x_values]
+  end
+
+end

data/lib/gimuby/genetic/solution/new_generation_strategy/combined_new_generation_strategy.rb

@@ -0,0 +1,27 @@
+require 'gimuby/genetic/solution/new_generation_strategy/new_generation_strategy'
+
+# This class pick randomly between strategies to implement more
+# mitigated new generation strategy
+class CombinedNewGenerationStrategy < NewGenerationStrategy
+
+  def initialize
+    @strategies = []
+  end
+
+  def reproduce(solution1, solution2)
+    strategy = get_concrete_strategy
+    strategy.reproduce(solution1, solution2)
+  end
+
+  # Add a strategy in the handled strategy of the system
+  # @param strategy {NewGenerationStrategy}
+  def add_strategy(strategy)
+    @strategies.push(strategy)
+  end
+
+  protected
+
+  def get_concrete_strategy
+    @strategies.choice
+  end
+end

data/lib/gimuby/genetic/solution/new_generation_strategy/cross_over_new_generation_strategy.rb

@@ -0,0 +1,40 @@
+require 'gimuby/genetic/solution/new_generation_strategy/new_generation_strategy'
+
+class CrossOverNewGenerationStrategy < NewGenerationStrategy
+
+  def initialize(cross_overs_number = 1)
+    @cross_overs_number = cross_overs_number
+  end
+
+  def reproduce(solution1, solution2)
+    permutation1 = solution1.get_solution_representation
+    permutation2 = solution2.get_solution_representation
+    cross_overs_number = @cross_overs_number
+    if cross_overs_number <= 0
+      cross_overs_number = permutation1.length - cross_overs_number
+    end
+    cross_overs_number.times do |_|
+      r = reproduce_step(permutation1, permutation2)
+      permutation1 = r.shift
+      permutation2 = r.shift
+    end
+    [permutation1, permutation2]
+  end
+
+  protected
+
+  def reproduce_step(permutation1, permutation2)
+    random_index = rand(permutation1.length)
+    if random_index == permutation1.length - 1
+      new_permutation1 = permutation1.clone()
+      new_permutation2 = permutation2.clone()
+    else
+      new_permutation1 = permutation1[0..random_index] +
+          permutation2[random_index + 1..-1]
+      new_permutation2 = permutation2[0..random_index] +
+          permutation1[random_index + 1..-1]
+    end
+    [new_permutation1, new_permutation2]
+  end
+
+end

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

@@ -0,0 +1,9 @@
+
+class NewGenerationStrategy
+
+  # Output an array of solution representations
+  def reproduce(solution1, solution2)
+    raise NotImplementedError
+  end
+
+end

data/lib/gimuby/genetic/solution/new_generation_strategy/parent_range_new_generation_strategy.rb

@@ -0,0 +1,42 @@
+require 'gimuby/genetic/solution/new_generation_strategy/new_generation_strategy'
+
+
+class ParentRangeNewGenerationStrategy < NewGenerationStrategy
+
+  def initialize(widen_range_ratio = 1.10)
+    @widen_range_ratio = widen_range_ratio
+  end
+
+  def reproduce(solution1, solution2)
+    x_values1 = solution1.get_solution_representation
+    x_values2 = solution2.get_solution_representation
+    reproduce_from_representation(x_values1, x_values2)
+  end
+
+  protected
+
+  def reproduce_from_representation(x_values1, x_values2)
+    new_values = []
+    x_values1.each_index do |i|
+      x_value1 = x_values1[i]
+      x_value2 = x_values2[i]
+      if x_value1.class == Array
+        new_x_value = reproduce_from_representation(x_value1, x_value2).pop
+      else
+        new_x_value = rand_in([x_value1, x_value2])
+      end
+      new_values.push(new_x_value)
+    end
+    [new_values]
+  end
+
+  def rand_in(values)
+    min = values.min
+    max = values.max
+    range = max - min
+    delta_range = range * @widen_range_ratio
+    range += delta_range
+    (rand() * range) + (min - delta_range / 2)
+  end
+
+end

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

@@ -0,0 +1,86 @@
+#!/usr/bin/env ruby
+require 'gimuby/config'
+require 'gimuby/dependencies'
+
+# Base class for solutions, extended by each given problem
+class Solution
+
+  def initialize(representation = nil)
+    @fitness = nil
+
+    @check_strategy ||= nil
+    @new_generation_strategy ||= nil
+    @mutation_strategy ||= nil
+
+    if representation.nil?
+      init_representation
+    else
+      set_solution_representation(representation)
+    end
+  end
+
+  attr_accessor :check_strategy
+  attr_accessor :new_generation_strategy
+  attr_accessor :mutation_strategy
+
+  # @return [Float]
+  def get_fitness
+    unless has_fitness?
+      @fitness = evaluate
+      event_data = {:solution => self}
+      get_event_manager.trigger_event(:on_solution_needs_evaluation, event_data)
+    end
+    @fitness
+  end
+
+  def reset_fitness_state
+    @fitness = nil
+  end
+
+  def mutate
+    @mutation_strategy.mutate(self)
+  end
+
+  def reproduce(sol1, sol2)
+    new_solutions_representations = @new_generation_strategy.reproduce(sol1, sol2)
+    new_solutions_representations.map do |representation|
+      solution = self.class.new(representation)
+      solution.check
+      solution.mutation_strategy = sol1.mutation_strategy
+      solution.check_strategy = sol1.check_strategy
+      solution.new_generation_strategy = sol1.new_generation_strategy
+      solution
+    end
+  end
+
+  def get_solution_representation
+    raise NotImplementedError
+  end
+
+  def set_solution_representation(representation)
+    raise NotImplementedError
+  end
+
+  protected
+
+  def init_representation
+    raise NotImplementedError
+  end
+
+  def has_fitness?
+    not @fitness.nil?
+  end
+
+  def evaluate
+    raise NotImplementedError
+  end
+
+  def check
+    checked_representation = @check_strategy.check(get_solution_representation)
+    set_solution_representation(checked_representation)
+  end
+
+  def get_event_manager
+    $dependencies.event_manager
+  end
+end

data/lib/gimuby/problem/foxholes/foxholes.rb

@@ -0,0 +1,76 @@
+require 'gimuby/config'
+
+# Implementation according to
+# http://www.sfu.ca/~ssurjano/shekel.html
+# http://www.zsd.ict.pwr.wroc.pl/files/docs/functions.pdf
+#
+class Foxholes
+
+  @@x_value_min = -65536
+  @@x_value_max = 65536
+
+  def initialize
+    ensure_holes_coordinates
+  end
+
+  def evaluate(x_values)
+    sum = 0.0
+    get_number_holes.times do |j|
+      hole_coordinate = @holes_coordinates[j]
+      sub_sum = 0.10
+      hole_coordinate.each_index do |i|
+        sub_sum += (x_values[i].to_f - hole_coordinate[i]) ** 2
+      end
+      sum += 1.0 / sub_sum
+    end
+    sum
+  end
+
+  protected
+
+  def get_number_holes
+    25
+  end
+
+  def get_holes_coordinates
+    @holes_coordinates
+  end
+
+  def ensure_holes_coordinates
+    path = $config.persistence_dir_path + '/foxholes_holes_coordinates_' +
+        get_number_holes.to_s + '.data'
+    load_holes_coordinates(path)
+    if @holes_coordinates.nil?
+      init_holes_coordinates
+      persist_holes_coordinates(path)
+    end
+  end
+
+  def load_holes_coordinates(path)
+    if File::exists? path
+      f = File.new(path, 'r')
+      @holes_coordinates = Marshal.load(f.read())
+      f.close()
+    end
+  end
+
+  def persist_holes_coordinates(path)
+    f = File.new(path, 'w')
+    f.write(Marshal.dump(@holes_coordinates))
+    f.close()
+  end
+
+  def init_holes_coordinates
+    @holes_coordinates = []
+    get_number_holes.times do |_|
+      @holes_coordinates.push(get_random_coordinates)
+    end
+  end
+
+  def get_random_coordinates
+    scale = @@x_value_max - @@x_value_min
+    x = rand() * scale + @@x_value_min
+    y = rand() * scale + @@x_value_min
+    [x, y]
+  end
+end

data/lib/gimuby/problem/foxholes/foxholes_solution.rb

@@ -0,0 +1,29 @@
+require 'gimuby/dependencies'
+require 'gimuby/config'
+require 'gimuby/genetic/solution/function_based_solution'
+
+class FoxholesSolution < FunctionBasedSolution
+
+  def evaluate
+    get_foxholes.evaluate(@x_values.clone)
+  end
+
+  protected
+
+  def get_x_value_min
+    -65536
+  end
+
+  def get_x_value_max
+    65536
+  end
+
+  def get_dimension_number
+    2
+  end
+
+  def get_foxholes
+    # load through dependency
+    $dependencies.foxholes
+  end
+end

data/lib/gimuby/problem/lennard_jones/lennard_jones.rb

@@ -0,0 +1,38 @@
+
+
+class LennardJones
+
+  def initialize
+    @sigma = 1
+  end
+
+  # @param atoms_positions {Array}
+  def evaluate(atoms_positions)
+    number = atoms_positions.length
+    potential = 0.0
+    (number - 1).times do |i|
+      atom_position_i = atoms_positions[i]
+      target_indices = *(i+1..number-1)
+      target_indices = [target_indices] unless target_indices.class == Array
+      target_indices.each do |j|
+        atom_position_j = atoms_positions[j]
+        distance = get_euclidian_distance(atom_position_i, atom_position_j)
+        if distance != 0
+          potential += (@sigma / distance) ** 12
+          potential -= (@sigma / distance) ** 6
+        end
+      end
+    end
+    potential * 4
+  end
+
+  protected
+
+  def get_euclidian_distance(atom_position1, atom_position2)
+    distance = 0.0
+    atom_position1.each_index do |k|
+      distance += (atom_position1[k] - atom_position2[k]) ** 2
+    end
+    Math.sqrt(distance)
+  end
+end

data/lib/gimuby/problem/lennard_jones/lennard_jones_solution.rb

@@ -0,0 +1,62 @@
+require 'gimuby/config'
+require 'gimuby/problem/lennard_jones/lennard_jones'
+require 'gimuby/genetic/solution/solution'
+
+class LennardJonesSolution < Solution
+
+  @@positions_dimensions = 3
+  @@position_dimension_min = -3.0
+  @@position_dimension_max = 3.0
+
+  def initialize(atoms_positions = nil)
+    super(atoms_positions)
+
+    @check_strategy = SolutionSpaceCheckStrategy.new
+    @check_strategy.set_min(@@position_dimension_min)
+    @check_strategy.set_max(@@position_dimension_max)
+
+    @new_generation_strategy = CombinedNewGenerationStrategy.new
+    @new_generation_strategy.add_strategy(ParentRangeNewGenerationStrategy.new)
+    @new_generation_strategy.add_strategy(CrossOverNewGenerationStrategy.new)
+
+    @mutation_strategy = SolutionSpaceMutationStrategy.new
+    @mutation_strategy.set_min(@@position_dimension_min)
+    @mutation_strategy.set_max(@@position_dimension_max)
+  end
+
+  def evaluate
+    get_lennard_jones.evaluate(get_solution_representation)
+  end
+
+  def get_solution_representation
+    @atoms_positions.clone
+  end
+
+  def set_solution_representation(atoms_positions)
+    @atoms_positions = atoms_positions.clone
+    #@atoms_positions = @atoms_positions.sort_by do |atom_position|
+    #  atom_position[0]
+    #end
+  end
+
+  protected
+
+  def init_representation
+    @atoms_positions = []
+    atoms_number = $config.lennard_jones_atoms
+    atoms_number.times do
+      atom_position = []
+      @@positions_dimensions.times do
+        position_dimension_range = (@@position_dimension_max - @@position_dimension_min)
+        position_dimension = (rand * position_dimension_range) + @@position_dimension_min
+        atom_position.push(position_dimension)
+      end
+      @atoms_positions.push(atom_position)
+    end
+  end
+
+  def get_lennard_jones
+    LennardJones.new
+  end
+
+end