gimuby 0.7.2

data/lib/gimuby/genetic/archipelago/connect_strategy/fully_connected_connect_strategy.rb

@@ -0,0 +1,11 @@
+require 'gimuby/genetic/archipelago/connect_strategy/connect_strategy'
+
+
+class FullyConnectedConnectStrategy < ConnectStrategy
+
+  def connect(archipelago)
+    nodes = get_nodes(archipelago)
+    make_fully_connected(archipelago, nodes)
+  end
+
+end

data/lib/gimuby/genetic/archipelago/connect_strategy/random_connect_strategy.rb

@@ -0,0 +1,29 @@
+require 'gimuby/genetic/archipelago/connect_strategy/connect_strategy'
+
+
+class RandomConnectStrategy < ConnectStrategy
+
+  def initialize
+    @average_degree = 4.0
+  end
+
+  attr_accessor :average_degree
+
+  def connect(archipelago)
+    nodes = get_nodes(archipelago)
+    connections_to_make = @average_degree * nodes.length
+    check_connections_to_make(connections_to_make, nodes)
+    made = 0
+    begin
+      from_node = nodes[rand(nodes.length)]
+      to_node = nodes[rand(nodes.length)]
+      has_edge = archipelago.has_edge(from_node, to_node)
+      if from_node != to_node || has_edge
+        archipelago.add_edge(from_node, to_node)
+        made += 1
+      end
+    end while made < connections_to_make
+    made
+  end
+
+end

data/lib/gimuby/genetic/archipelago/connect_strategy/watts_strogatz_connect_strategy.rb

@@ -0,0 +1,63 @@
+require 'gimuby/genetic/archipelago/connect_strategy/connect_strategy'
+
+class WattsStrogatzConnectStrategy < ConnectStrategy
+
+  def initialize
+    @average_degree = 4.0
+    @rewire_rate = 0.2
+  end
+
+  attr_accessor :average_degree
+  attr_accessor :rewire_rate
+
+  def connect(archipelago)
+    make_regular_latice(archipelago)
+    rewire(archipelago)
+  end
+
+  protected
+
+  def make_regular_latice(archipelago)
+    depth = (@average_degree / 2).floor
+    depth.times do |i|
+      # create a circle
+      # then create a path with all second range neighbor
+      # until reaching depth
+      current_depth = i + 1
+      current_depth.times do |first_node_index|
+        # if depth = 2, there is two paths to build
+        # [0, 2, 4, ...] and [1, 3, 5, ...]
+        nodes = get_nodes(archipelago)
+        path = []
+        nodes.each_with_index do |key, node|
+          if (key % current_depth) == first_node_index
+            path.push(node)
+          end
+        end
+        archipelago.connect_path(path, TRUE)
+      end
+    end
+  end
+
+  def rewire(archipelago)
+    edges = get_edges_to_rewire(archipelago)
+    nodes = get_nodes(archipelago)
+    edges.each do |edge|
+      node1 = edge[0]
+      node2 = edge[1]
+      if node1 < node2 # we do not process the other case (undirected model)
+        should_rewire = @rewire_rate < rand()
+        if should_rewire
+          new_node = nodes.choice while archipelago.has_edge(node1, new_node)
+          archipelago.remove_edge(node1, node2)
+          archipelago.connect(node1, new_node)
+        end
+      end
+    end
+  end
+
+  def get_edges_to_rewire(archipelago)
+    archipelago.get_edges
+  end
+
+end

data/lib/gimuby/genetic/archipelago/measure/clustering_coefficient_measure.rb

@@ -0,0 +1,92 @@
+require 'gimuby/genetic/archipelago/measure/measure'
+
+# Compute the network average clustering coefficient as defined on
+# http://en.wikipedia.org/wiki/Clustering_coefficient#Network_average_clustering_coefficient
+# revision 19:31, 6 July 2013
+#
+# Beware if you update code, this class has a state don't break the
+# workflow around the @potential_clusters member
+class ClusteringCoefficientMeasure < Measure
+
+  # @param archipelago [Archipelago]
+  # @return [float] the clustering coefficient
+  def compute(archipelago)
+    local_clustering_coefficients = []
+    archipelago.get_nodes.each do |node|
+      local_clustering_coefficient = get_local_clustering_coefficient(archipelago, node)
+      local_clustering_coefficients.push(local_clustering_coefficient)
+    end
+    local_clustering_coefficients.inject(:+) / local_clustering_coefficients.length.to_f
+  end
+
+  private
+
+  def get_local_clustering_coefficient(archipelago, node)
+    init_local_computation_properties
+    potential_clusters_count = compute_potential_local_clusters(archipelago, node).length
+    clusters_count = compute_real_local_clusters(archipelago).length
+    if potential_clusters_count == 0
+      return 0
+    end
+    clusters_count.to_f / potential_clusters_count.to_f
+  end
+
+  def init_local_computation_properties
+    @potential_clusters = []
+  end
+
+  def compute_potential_local_clusters(archipelago, node)
+    neighbors = archipelago.get_neighbors(node)
+    neighbors.each do |neighbor1|
+      neighbors.each do |neighbor2|
+        #print '---------'
+        #print "\n"
+        #print neighbors.join('  ')
+        #print "\n"
+        #print node, ' ', neighbor1, ' ', neighbor2
+        #print "\n"
+        register_potential_clusters(node, neighbor1, neighbor2)
+      end
+    end
+    @potential_clusters
+  end
+
+  def compute_real_local_clusters(archipelago)
+    clusters = []
+    @potential_clusters.each do |potential_cluster|
+      node1 = potential_cluster[0]
+      node2 = potential_cluster[1]
+      node3 = potential_cluster[2]
+      fully_connected = archipelago.has_edge(node1, node2) && \
+                        archipelago.has_edge(node3, node2) && \
+                        archipelago.has_edge(node1, node3)
+      if fully_connected
+        clusters.push(potential_cluster.clone)
+      end
+    end
+    clusters
+  end
+
+  def register_potential_clusters(node1, node2, node3)
+    if node1 == node2
+      # invalid set
+      return FALSE
+    end
+    nodes = [node1, node2]
+    if nodes.include?(node3)
+      # invalid set
+      return FALSE
+    end
+    nodes.push(node3)
+    nodes.each do |node|
+      return FALSE if node.nil?
+    end
+    nodes.sort!
+    if @potential_clusters.include?(nodes)
+      # value already taken into account
+      return FALSE
+    end
+    @potential_clusters.push(nodes)
+    TRUE
+  end
+end

data/lib/gimuby/genetic/archipelago/measure/connected_measure.rb

@@ -0,0 +1,64 @@
+require 'gimuby/genetic/archipelago/measure/measure'
+
+# Return the number of connected class for an archipelago
+class ConnectedMeasure < Measure
+
+  # @param archipelago {Archipelago}
+  def compute(archipelago)
+    init_connected_classes(archipelago)
+    old_signature = get_state_signature
+    new_signature = ''
+    until old_signature == new_signature
+      old_signature = new_signature
+      try_to_reduce(archipelago)
+      new_signature = get_state_signature
+    end
+    get_connected_classes_count
+  end
+
+  private
+
+  def init_connected_classes(archipelago)
+    nodes = archipelago.get_nodes
+    @connected_classes = {}
+    nodes.each do |node|
+      @connected_classes[node] = node
+    end
+  end
+
+  def get_state_signature
+    signature = ''
+    @connected_classes.each do |k, v|
+      signature = '|' + k.to_s + '-->' + v.to_s + "\n"
+    end
+    signature
+  end
+
+  def get_connected_classes_count
+    different_classes = []
+    @connected_classes.each do |_, connected_class|
+      unless different_classes.include?(connected_class)
+        different_classes.push(connected_class)
+      end
+    end
+    different_classes.length
+  end
+
+  # @param archipelago {Archipelago}
+  def try_to_reduce(archipelago)
+    @connected_classes.each do |key1, value1|
+      @connected_classes.each do |key2, value2|
+        unless (key1 == key2) || (value1 == value2)
+          if archipelago.has_edge(key1, key2)
+            if value1 < value2
+              @connected_classes[key2] = value1
+            else
+              @connected_classes[key1] = value2
+            end
+          end
+        end
+      end
+    end
+  end
+
+end

data/lib/gimuby/genetic/archipelago/measure/diameter_measure.rb

@@ -0,0 +1,38 @@
+require 'gimuby/genetic/archipelago/measure/measure'
+require 'gimuby/genetic/archipelago/measure/shortest_paths_measure'
+require 'gimuby/genetic/archipelago/measure/connected_measure'
+
+
+# Return the diameter of an archipelago
+# If archipelago is not connex, simply output twice number of its nodes
+class DiameterMeasure < Measure
+
+  def compute(archipelago)
+    unless is_connected(archipelago)
+      return 2 * archipelago.get_nodes.length
+    end
+    get_biggest_shortest_paths(archipelago)
+  end
+
+  private
+
+  def is_connected(archipelago)
+    connected_measure = get_connected_measure
+    connected_classes_count = connected_measure.compute(archipelago)
+    connected_classes_count == 1
+  end
+
+  def get_biggest_shortest_paths(archipelago)
+    paths_lengths = get_shortest_paths_measure.compute(archipelago)
+    paths_lengths.max
+  end
+
+  def get_connected_measure
+    ConnectedMeasure.new
+  end
+
+  def get_shortest_paths_measure
+    ShortestPathsMeasure.new
+  end
+
+end

data/lib/gimuby/genetic/archipelago/measure/measure.rb

@@ -0,0 +1,7 @@
+
+class Measure
+
+  def compute(archipelago)
+    NotImplementedError
+  end
+end

data/lib/gimuby/genetic/archipelago/measure/shortest_paths_measure.rb

@@ -0,0 +1,46 @@
+require 'gimuby/genetic/archipelago/measure/measure'
+
+# Return the list of shortest path (Dijkstra) in Archipelago
+class ShortestPathsMeasure < Measure
+
+  def compute(archipelago)
+    nodes = archipelago.get_nodes
+    shortest_paths_length = []
+    nodes.each do |node1|
+      nodes.each do |node2|
+        if node2 > node1
+          length = get_shortest_path_length(archipelago, node1, node2)
+          unless length.nil?
+            shortest_paths_length.push(length)
+          end
+        end
+      end
+    end
+    shortest_paths_length
+  end
+
+  private
+
+  def get_shortest_path_length(archipelago, node1, node2)
+    next_nodes = [node1]
+    current_neighbor_distance = 0
+    nodes_distances = {node1 => current_neighbor_distance}
+    while next_nodes.length != 0
+      current_node = next_nodes.shift
+      current_neighbor_distance = nodes_distances[current_node] + 1
+      neighbors = archipelago.get_neighbors(current_node)
+      neighbors.each do |neighbor_node|
+        already_processed = nodes_distances.has_key?(neighbor_node)
+        unless already_processed
+          next_nodes.push neighbor_node
+          nodes_distances[neighbor_node] = current_neighbor_distance
+        end
+      end
+      if nodes_distances.has_key?(node2)
+        return nodes_distances[node2]
+      end
+    end
+    nil
+  end
+
+end

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

@@ -0,0 +1,17 @@
+require 'gimuby/genetic/population/pick_strategy/pick_strategy'
+
+class BestsPickStrategy < PickStrategy
+
+  def pick(population)
+    solutions = population.solutions
+    number = get_number_to_pick(population)
+    candidates = solutions.clone
+
+    candidates.sort! do |x, y|
+      (population.get_fitness x) <=> (population.get_fitness y)
+    end
+
+    candidates.slice(0, number)
+  end
+
+end

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

@@ -0,0 +1,21 @@
+
+class PickStrategy
+
+  def initialize
+    @pick_proportion ||= 25.to_f / 100.to_f
+  end
+
+  attr_accessor :pick_proportion
+
+  # pick some solution inside the population
+  def pick(population)
+    raise NotImplementedError
+  end
+
+  protected
+
+  def get_number_to_pick(population)
+    number = population.solutions.length * @pick_proportion
+    number.round
+  end
+end

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

@@ -0,0 +1,40 @@
+require 'gimuby/genetic/population/pick_strategy/pick_strategy'
+
+class RandomWheelPickStrategy < PickStrategy
+
+  def initialize
+    super
+    @random_wheel_probability_reason = 0.7
+  end
+
+  attr_accessor :random_wheel_probability_reason
+
+  def pick(population)
+    number = get_number_to_pick(population)
+    reason = @random_wheel_probability_reason
+    solutions = population.solutions
+    candidates = solutions.clone
+    candidates.sort! do |x, y|
+      (population.get_fitness x) <=> (population.get_fitness y)
+    end
+    picked = []
+    begin
+      # we use a geometric sequence
+      max_of_the_rand = (1 - reason ** candidates.length) / (1 - reason)
+      r = rand() * max_of_the_rand
+      element = 1
+      candidates.each do |solution|
+        max_accepted_value = (1 - reason ** element) / (1 - reason)
+        element += 1
+        if max_accepted_value > r
+          picked.push solution
+          ind = candidates.index solution
+          candidates.slice! ind
+          break
+        end
+      end
+    end while picked.length < number
+    picked
+  end
+
+end

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

@@ -0,0 +1,26 @@
+require 'gimuby/genetic/population/pick_strategy/pick_strategy'
+
+class TournamentPickStrategy < PickStrategy
+
+  def pick(population)
+    solutions = population.solutions
+    number = get_number_to_pick(population)
+    candidates = solutions.clone
+
+    while candidates.length > number:
+      sol1 = candidates.choice()
+      sol2 = sol1
+      while sol1 == sol2:
+        sol2 = candidates.choice()
+      end
+      if population.get_fitness(sol1) < population.get_fitness(sol2)
+        candidates.delete(sol2)
+      else
+        candidates.delete(sol1)
+      end
+    end
+
+    candidates
+  end
+
+end