gimuby 0.7.2

data/Gemfile

@@ -0,0 +1 @@
+rake

data/LICENSE.md

@@ -0,0 +1,25 @@
+The MIT License
+===============
+
+Copyright © 2014 Fräntz Miccoli
+
+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:
+
+Except as contained in this notice, the name(s) of the above copyright holders 
+shall not be used in advertising or otherwise to promote the sale, use or other 
+dealings in this Software without prior written authorization.
+
+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/lib/gimuby.rb

@@ -0,0 +1,10 @@
+require 'gimuby/dependencies'
+require 'gimuby/factory'
+
+module Gimuby
+
+  def self.get_factory
+    Factory.new
+  end
+
+end

data/lib/gimuby/config.rb

@@ -0,0 +1,39 @@
+
+# Please note that the default are important to let unit test run perfectly
+class GimubyConfig
+
+  def initialize
+    @persistence_dir_path = '/tmp'
+
+    # Problem specific configuration
+
+    # TSP
+    @tsp_number_points = 100
+
+    # Rastrigin
+    @rastrigin_dimension = 20
+
+    # Lennard Jones
+    @lennard_jones_atoms = 31
+  end
+
+  attr_accessor :persistence_dir_path
+
+  attr_accessor :problem
+
+  # TSP
+  attr_accessor :tsp_number_points
+
+  # Rastrigin
+  attr_accessor :rastrigin_dimension
+
+  # Lennard Jones
+  attr_accessor :lennard_jones_atoms
+
+  attr_accessor :optimal_population
+  attr_accessor :optimal_archipelago
+
+end
+
+$config = GimubyConfig.new()
+

data/lib/gimuby/dependencies.rb

@@ -0,0 +1,37 @@
+require 'gimuby/factory'
+require 'gimuby/event/event_manager'
+require 'gimuby/problem/tsp/tsp'
+require 'gimuby/problem/foxholes/foxholes'
+
+# Dependencies container that is accessed from everywhere in the app
+class Dependencies
+
+  def initialize
+    @event_manager = EventManager.new
+
+    # problem specific
+    @tsp = nil
+    @foxholes = nil
+  end
+
+  attr_accessor :event_manager
+
+  # problem specific
+
+  def tsp
+    if @tsp.nil?
+      @tsp = Tsp.new
+    end
+    @tsp
+  end
+
+  def foxholes
+    if @foxholes.nil?
+      @foxholes = Foxholes.new
+    end
+    @foxholes
+  end
+
+end
+
+$dependencies = Dependencies.new

data/lib/gimuby/event/event.rb

@@ -0,0 +1,29 @@
+require 'gimuby/dependencies'
+
+class Event
+
+  # @param format [String]  The name of the event
+  # @param data [Hash]      An Hash containing the data that will be passed
+  #                         to the listeners
+  # @api
+  def initialize(name = nil?, data = {})
+    @name = name
+    @data = data
+  end
+
+  attr_accessor :name
+  attr_accessor :data
+
+  # Trigger the event (through the event manager)
+  # @api
+  def trigger
+    event_manager = get_event_manager
+    event_manager.trigger_event(name, self)
+  end
+
+  protected
+
+  def get_event_manager
+    $dependencies.event_manager
+  end
+end

data/lib/gimuby/event/event_manager.rb

@@ -0,0 +1,34 @@
+require 'gimuby/event/event'
+
+# Core of the event managing system, this class stores listener and call them
+# on event triggering.
+class EventManager
+
+  def initialize
+    @listeners_registry = {} #contains array
+  end
+
+  # @param name {String} The event name
+  # @param block {Block} The callback that will be call
+  # @api
+  def register_listener(name, &block)
+    unless @listeners_registry.has_key? name
+      @listeners_registry[name] = []
+    end
+    @listeners_registry[name].push block
+  end
+
+  # @param name {String}  The event name
+  # @param event {Event}   The event object
+  def trigger_event(name, event = {})
+    if @listeners_registry.has_key? name
+      if event.class == Hash
+        event = Event.new(name, event)
+      end
+      listeners = @listeners_registry[name]
+      listeners.each do |block|
+        block.call event
+      end
+    end
+  end
+end

data/lib/gimuby/factory.rb

@@ -0,0 +1,275 @@
+require 'gimuby/dependencies'
+require 'gimuby/config'
+require 'gimuby/genetic/archipelago/archipelago'
+require 'gimuby/genetic/population/population'
+require 'gimuby/genetic/population/pick_strategy/bests_pick_strategy'
+require 'gimuby/genetic/population/pick_strategy/random_wheel_pick_strategy'
+require 'gimuby/genetic/population/pick_strategy/tournament_pick_strategy'
+require 'gimuby/genetic/population/replace_strategy/replace_worst_replace_strategy'
+require 'gimuby/genetic/population/replace_strategy/uniform_replace_strategy'
+require 'gimuby/genetic/archipelago/connect_strategy/circle_connect_strategy'
+require 'gimuby/genetic/archipelago/connect_strategy/fully_connected_connect_strategy'
+require 'gimuby/genetic/archipelago/connect_strategy/random_connect_strategy'
+require 'gimuby/genetic/archipelago/connect_strategy/constant_degree_connect_strategy'
+require 'gimuby/genetic/archipelago/connect_strategy/barabasi_albert_connect_strategy'
+require 'gimuby/genetic/archipelago/connect_strategy/watts_strogatz_connect_strategy'
+require 'gimuby/problem/tsp/tsp_solution'
+require 'gimuby/problem/rastrigin/rastrigin_solution'
+require 'gimuby/problem/lennard_jones/lennard_jones_solution'
+require 'gimuby/problem/schaffer/schaffer_solution'
+require 'gimuby/problem/rosenbrock/rosenbrock_solution'
+require 'gimuby/problem/step/step_solution'
+require 'gimuby/problem/sphere/sphere_solution'
+require 'gimuby/problem/foxholes/foxholes_solution'
+
+class Factory
+
+  def initialize
+    @optimal_population = FALSE
+    @optimal_archipelago = FALSE
+
+    # use for test purpose to avoid provided archipelago to be connected
+    @connected_archipelago = TRUE
+
+    # those values are set by the user, let them nil and we won't use them
+    @solutions_number = nil
+    @populations_number = nil
+
+    # if we have to generate values we store them here
+    @_solutions_number = nil
+    @_populations_number = nil
+  end
+
+  attr_accessor :optimal_population
+  attr_accessor :optimal_archipelago
+
+  attr_accessor :connected_archipelago
+
+  attr_accessor :solutions_number
+  attr_accessor :populations_number
+
+  def reset_state
+    @connected_archipelago = TRUE
+    @_populations_number = nil
+    @_solutions_number = nil
+  end
+
+  def get_population(&solution_generator)
+    _get_population(:population, &solution_generator)
+  end
+
+  def get_archipelago(&solution_generator)
+    if @optimal_archipelago
+      return get_optimal_archipelago(&solution_generator)
+    end
+    get_random_archipelago(&solution_generator)
+  end
+
+  def get_optimal_population(optimizer, &solution_generator)
+    candidate_population = get_random_population(optimizer, &solution_generator)
+    begin
+      candidate_population = get_random_population(optimizer, &solution_generator)
+      if candidate_population.solutions.length >= 1000
+        next
+      end
+      if candidate_population.solutions[0].mutation_strategy.mutation_rate >= 0.1
+        next
+      end
+      if candidate_population.replace_strategy.replace_proportion <= 0.4
+        next
+      end
+      if candidate_population.pick_strategy.pick_proportion >= 0.4
+        next
+      end
+    end while FALSE
+    candidate_population
+  end
+
+  def get_optimal_archipelago(&solution_generator)
+    is_optimal = FALSE
+    begin
+      candidate_archipelago = get_random_archipelago(&solution_generator)
+      is_optimal = TRUE
+      if (candidate_archipelago.get_population_size <= 500) or
+          (candidate_archipelago.get_population_size >= 1100)
+        is_optimal = FALSE
+      end
+      if candidate_archipelago.migration_rate <= 0.25
+        is_optimal = FALSE
+      end
+      if (candidate_archipelago.populations.length < 10) or
+          (candidate_archipelago.populations.length > 29)
+        is_optimal = FALSE
+      end
+      if candidate_archipelago.get_diameter >= 100
+        is_optimal = FALSE
+      end
+    end until is_optimal
+    candidate_archipelago
+  end
+
+  def get_random_population(optimizer, &solution_generator)
+    population = Population.new
+    population.pick_strategy = get_random_pick_strategy
+    population.replace_strategy = get_random_replace_strategy
+    populations_number = get_populations_number
+    unless optimizer == :archipelago
+      populations_number = 1
+    end
+    solutions_number = get_solutions_number(populations_number)
+    number_solutions_per_population = solutions_number / populations_number
+    mutation_rate = rand * 0.7
+    number_solutions_per_population.times do
+      solution = solution_generator.call
+      solution.mutation_strategy.mutation_rate = mutation_rate
+      population.add_solution(solution)
+    end
+
+    population
+  end
+
+  def get_random_archipelago(&solution_generator)
+    archipelago = Archipelago.new
+    archipelago.connect_strategy = get_random_connect_strategy
+    # between 0.01% and ~35%
+    archipelago.migration_rate = (rand() * 35.0 / 100.0) + 0.0001
+    archipelago.migration_symmetric = [true, false].choice
+    archipelago.migration_type = [:random, :synchronized, :fixed_time].choice
+    get_populations_number.times do |_|
+      archipelago.add_population(_get_population(:archipelago, &solution_generator))
+    end
+    if @connected_archipelago
+      archipelago.connect_all
+    end
+    archipelago
+  end
+
+  protected
+
+  def _get_population(optimizer, &solution_generator)
+    if @optimal_population
+      return get_optimal_population(optimizer, &solution_generator)
+    end
+    get_random_population(optimizer, &solution_generator)
+  end
+
+  def get_solutions_number(populations_number = 1)
+    unless @_solutions_number.nil?
+      return @_solutions_number
+    end
+    unless @solutions_number.nil?
+      return @solutions_number
+    end
+
+    max_population_size = 5000
+    min_population_size = 12 * populations_number
+    if @optimal_population
+      max_population_size = 1000
+    end
+    if @optimal_archipelago
+      min_population_size = 500
+      max_population_size = [max_population_size, 1100].min
+    end
+
+    solutions_number_range = *(min_population_size..max_population_size)
+    picked_solutions_number = 0
+    solutions_per_population = 0
+    min_solutions_per_population = min_population_size / populations_number
+    begin
+      picked_solutions_number = solutions_number_range.choice
+      picked_solutions_number /= populations_number
+      picked_solutions_number *= populations_number
+      solutions_per_population = picked_solutions_number / populations_number
+    end while solutions_per_population < min_solutions_per_population
+
+    @_solutions_number = picked_solutions_number
+    @_solutions_number
+  end
+
+  def get_populations_number
+    unless @_populations_number.nil?
+      return @_populations_number
+    end
+    unless @populations_number.nil?
+      @_populations_number = @populations_number
+      return @_populations_number
+    end
+
+    populations_number_range = *(2..100)
+    if @optimal_archipelago
+      populations_number_range = *(10..29)
+    end
+
+    @_populations_number = populations_number_range.choice
+    @_populations_number
+  end
+
+  def get_random_pick_strategy
+    max = 10
+    r = rand(max)
+    if r == 0
+      return BestsPickStrategy.new
+    elsif r == 1
+      return TournamentPickStrategy.new
+    end
+    r = rand(9) + 1
+    strategy = RandomWheelPickStrategy.new
+    reason = 1.0 / 10.0 * r
+    strategy.random_wheel_probability_reason = reason
+
+    # pick proportion
+    min = 0.1
+    max = 0.9
+    spread = max - min
+    strategy.pick_proportion = (rand() * spread) + min
+
+    strategy
+  end
+
+  def get_random_replace_strategy
+    if rand() < 0.2
+      strategy = UniformReplaceStrategy.new
+    else
+      strategy = ReplaceWorstReplaceStrategy.new
+    end
+
+    # replace proportion
+    min = 0.05
+    max = 1.0
+    spread = max - min
+    replace_proportion = (rand() * spread) + min
+    strategy.replace_proportion = replace_proportion
+    strategy
+  end
+
+  def get_random_connect_strategy
+    r = rand(10)
+    if r == 0
+      return CircleConnectStrategy.new
+    end
+    if r == 1
+      return FullyConnectedConnectStrategy.new
+    end
+    r = rand(4)
+    max_degree = [22, get_populations_number - 1].min
+    # even number means easier by two divisions
+    average_degree = (rand((max_degree - 1)/ 2) + 1) * 2
+    # avoid a bug on an edge case when max_degree = 2
+    average_degree = [average_degree, max_degree].min
+    case r
+      when 0
+        strategy = RandomConnectStrategy.new
+      when 1
+        strategy = ConstantDegreeConnectStrategy.new
+      when 2
+        strategy = BarabasiAlbertConnectStrategy.new
+      when 3
+        strategy = WattsStrogatzConnectStrategy.new
+      else
+        raise 'random value (r) has an unexpected value'
+    end
+    strategy.average_degree = average_degree
+    strategy
+  end
+
+end