Algorithmically 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 90dbca96e9a153e6acfbdd2eac99f9e06054aa73
-  data.tar.gz: a1a059aab483649dae1d890df74549a20cda0b42
+  metadata.gz: c6b37344d80011486740e722946df13475c44ba5
+  data.tar.gz: 46afbc8274889d7660acf6fd42f5e3e78260851e
 SHA512:
-  metadata.gz: 9afc0731375aa0fae820aa4605b87ce7992f484430faaf0c1eabba5fa91eaf785c36457e4613c2c622e51078667a3ecec57f519243114cd3a0e7765e0c3f4029
-  data.tar.gz: 7d30e282bc64b82fe5683b33308e218cea14ed76100841f314fc3a02ab14c4399a8faa62ed9e4c5aee866ac4acee44fb37cb1124ca513d1846225cf32fb2a541
+  metadata.gz: 1831736b94dc14f2234ebfe1c2ca1c3c33f9d1ff301dd81f070c97bce781e517e38929ba6579467f60fda7093f3d267aa71fc28736850f97ae42c9775c4c75e0
+  data.tar.gz: a68582cd9aebbb76d27b047643d5160ba6ce1e352e45299512088dfcfbc326d5a8a2f22b58d21006098b1af2b9cdc7701210c7eb481294af92b99504e71e7066

data/README.md

@@ -22,20 +22,20 @@ Or install it yourself as:
 
 ### Evolutionary Algorithms
 
-    Algorithmically::Genetic.new(100, 64, 100, 0.98)
+    Algorithmically::Evolutionary::Genetic.new(100, 64, 100, 0.98)
 
 ### Neural Algorithms
 
-    Algorithmically::Perceptron.new([[0,0,0], [0,1,1], [1,0,1], [1,1,1]], 2, 20, 0.1)
+    Algorithmically::Neural::Perceptron.new([[0,0,0], [0,1,1], [1,0,1], [1,1,1]], 2, 20, 0.1)
 
 ### Stochastic Algorithms
     
-    Algorithmically::RandomSearch.new(2, 50)
+    Algorithmically::Neural::RandomSearch.new(2, 50)
 
-    Algorithmically::AdaptiveRandomSearch.new(1000, 2, 0.05, 1.3, 3.0, 10, 30)
+    Algorithmically::Neural::AdaptiveRandomSearch.new(1000, 2, 0.05, 1.3, 3.0, 10, 30)
     
-    Algorithmically::HillClimbing.new(2, 1000)
+    Algorithmically::Neural::HillClimbing.new(2, 1000)
     
-    Algorithmically::GuidedLocalSearch.new(150, [[565,575],[25,185],[345,750],[945,685]], 20, 0.3)
+    Algorithmically::Neural::GuidedLocalSearch.new(150, [[565,575],[25,185],[345,750],[945,685]], 20, 0.3)
 
 

data/lib/Algorithmically/Evolutionary/genetic.rb

@@ -1,77 +1,79 @@
-module Evolutionary
+module Algorithmically
+  module Evolutionary
 
-  class Genetic
+    class Genetic
 
-    def initialize(max_gens, num_bits, pop_size, p_crossover)
-      p_mutation = 1.0/num_bits
-      best = search(max_gens, num_bits, pop_size, p_crossover, p_mutation)
-      puts "done! Solution: f=#{best[:fitness]}, s=#{best[:bitstring]}"
-    end
-
-    def onemax(bitstring)
-      sum = 0
-      bitstring.size.times { |i| sum+=1 if bitstring[i].chr=='1' }
-      sum
-    end
+      def initialize(max_gens, num_bits, pop_size, p_crossover)
+        p_mutation = 1.0/num_bits
+        best = search(max_gens, num_bits, pop_size, p_crossover, p_mutation)
+        puts "done! Solution: f=#{best[:fitness]}, s=#{best[:bitstring]}"
+      end
 
-    def random_bitstring(num_bits)
-      (0...num_bits).inject("") { |s, i| s<<((rand<0.5) ? "1" : "0") }
-    end
+      def onemax(bitstring)
+        sum = 0
+        bitstring.size.times { |i| sum+=1 if bitstring[i].chr=='1' }
+        sum
+      end
 
-    def binary_tournament(pop)
-      i, j = rand(pop.size), rand(pop.size)
-      j = rand(pop.size) if j==i
-      (pop[i][:fitness] > pop[j][:fitness]) ? pop[i] : pop[j]
-    end
+      def random_bitstring(num_bits)
+        (0...num_bits).inject("") { |s, i| s<<((rand<0.5) ? "1" : "0") }
+      end
 
-    def point_mutation(bitstring, rate=1.0/bitstring.size)
-      child = ""
-      bitstring.size.times do |i|
-        bit = bitstring[i].chr
-        child << ((rand()<rate) ? ((bit=='1') ? "0" : "1") : bit)
+      def binary_tournament(pop)
+        i, j = rand(pop.size), rand(pop.size)
+        j = rand(pop.size) if j==i
+        (pop[i][:fitness] > pop[j][:fitness]) ? pop[i] : pop[j]
       end
-      child
-    end
 
-    def crossover(parent1, parent2, rate)
-      ""+parent1 if rand()>=rate
-      point = 1 + rand(parent1.size-2)
-      parent1[0...point]+parent2[point...(parent1.size)]
-    end
+      def point_mutation(bitstring, rate=1.0/bitstring.size)
+        child = ""
+        bitstring.size.times do |i|
+          bit = bitstring[i].chr
+          child << ((rand()<rate) ? ((bit=='1') ? "0" : "1") : bit)
+        end
+        child
+      end
 
-    def reproduce(selected, pop_size, p_cross, p_mutation)
-      children = []
-      selected.each_with_index do |p1, i|
-        p2 = (i.modulo(2)==0) ? selected[i+1] : selected[i-1]
-        p2 = selected[0] if i == selected.size-1
-        child = {}
-        child[:bitstring] = crossover(p1[:bitstring], p2[:bitstring], p_cross)
-        child[:bitstring] = point_mutation(child[:bitstring], p_mutation)
-        children << child
-        children.size >= pop_size
+      def crossover(parent1, parent2, rate)
+        ""+parent1 if rand()>=rate
+        point = 1 + rand(parent1.size-2)
+        parent1[0...point]+parent2[point...(parent1.size)]
       end
-      children
-    end
 
-    def search(max_gens, num_bits, pop_size, p_crossover, p_mutation)
-      population = Array.new(pop_size) do |i|
-        {:bitstring => random_bitstring(num_bits)}
+      def reproduce(selected, pop_size, p_cross, p_mutation)
+        children = []
+        selected.each_with_index do |p1, i|
+          p2 = (i.modulo(2)==0) ? selected[i+1] : selected[i-1]
+          p2 = selected[0] if i == selected.size-1
+          child = {}
+          child[:bitstring] = crossover(p1[:bitstring], p2[:bitstring], p_cross)
+          child[:bitstring] = point_mutation(child[:bitstring], p_mutation)
+          children << child
+          children.size >= pop_size
+        end
+        children
       end
-      population.each { |c| c[:fitness] = onemax(c[:bitstring]) }
-      best = population.sort { |x, y| y[:fitness] <=> x[:fitness] }.first
-      max_gens.times do |gen|
-        selected = Array.new(pop_size) { |i| binary_tournament(population) }
-        children = reproduce(selected, pop_size, p_crossover, p_mutation)
-        children.each { |c| c[:fitness] = onemax(c[:bitstring]) }
-        children.sort! { |x, y| y[:fitness] <=> x[:fitness] }
-        best = children.first if children.first[:fitness] >= best[:fitness]
-        population = children
-        puts " > gen #{gen}, best: #{best[:fitness]}, #{best[:bitstring]}"
-        break best[:fitness] == num_bits
+
+      def search(max_gens, num_bits, pop_size, p_crossover, p_mutation)
+        population = Array.new(pop_size) do |i|
+          {:bitstring => random_bitstring(num_bits)}
+        end
+        population.each { |c| c[:fitness] = onemax(c[:bitstring]) }
+        best = population.sort { |x, y| y[:fitness] <=> x[:fitness] }.first
+        max_gens.times do |gen|
+          selected = Array.new(pop_size) { |i| binary_tournament(population) }
+          children = reproduce(selected, pop_size, p_crossover, p_mutation)
+          children.each { |c| c[:fitness] = onemax(c[:bitstring]) }
+          children.sort! { |x, y| y[:fitness] <=> x[:fitness] }
+          best = children.first if children.first[:fitness] >= best[:fitness]
+          population = children
+          puts " > gen #{gen}, best: #{best[:fitness]}, #{best[:bitstring]}"
+          break best[:fitness] == num_bits
+        end
+        best
       end
-      best
+
     end
 
   end
-
 end

data/lib/Algorithmically/Neural/perceptron.rb

@@ -1,78 +1,80 @@
-module Neural
+module Algorithmically
+  module Neural
 
-  class Perceptron
+    class Perceptron
 
-    def initialize(or_problem, inputs, iterations, learning_rate)
-      execute(or_problem, inputs, iterations, learning_rate)
-    end
+      def initialize(or_problem, inputs, iterations, learning_rate)
+        execute(or_problem, inputs, iterations, learning_rate)
+      end
 
-    def random_vector(minmax)
-      Array.new(minmax.size) do |i|
-        minmax[i][0] + ((minmax[i][1] - minmax[i][0]) * rand())
+      def random_vector(minmax)
+        Array.new(minmax.size) do |i|
+          minmax[i][0] + ((minmax[i][1] - minmax[i][0]) * rand())
+        end
       end
-    end
 
-    def initialize_weights(problem_size)
-      minmax = Array.new(problem_size + 1) { [-1.0, 1.0] }
-      random_vector(minmax)
-    end
+      def initialize_weights(problem_size)
+        minmax = Array.new(problem_size + 1) { [-1.0, 1.0] }
+        random_vector(minmax)
+      end
 
-    def update_weights(num_inputs, weights, input, out_exp, out_act, l_rate)
-      num_inputs.times do |i|
-        weights[i] += l_rate * (out_exp - out_act) * input[i]
+      def update_weights(num_inputs, weights, input, out_exp, out_act, l_rate)
+        num_inputs.times do |i|
+          weights[i] += l_rate * (out_exp - out_act) * input[i]
+        end
+        weights[num_inputs] += l_rate * (out_exp - out_act) * 1.0
       end
-      weights[num_inputs] += l_rate * (out_exp - out_act) * 1.0
-    end
 
-    def activate(weights, vector)
-      sum = weights[weights.size-1] * 1.0
-      vector.each_with_index do |input, i|
-        sum += weights[i] * input
+      def activate(weights, vector)
+        sum = weights[weights.size-1] * 1.0
+        vector.each_with_index do |input, i|
+          sum += weights[i] * input
+        end
+        sum
       end
-      sum
-    end
 
-    def transfer(activation)
-      (activation >= 0) ? 1.0 : 0.0
-    end
+      def transfer(activation)
+        (activation >= 0) ? 1.0 : 0.0
+      end
 
-    def get_output(weights, vector)
-      activation = activate(weights, vector)
-      transfer(activation)
-    end
+      def get_output(weights, vector)
+        activation = activate(weights, vector)
+        transfer(activation)
+      end
+
+      def train_weights(weights, domain, num_inputs, iterations, lrate)
+        iterations.times do |epoch|
+          error = 0.0
+          domain.each do |pattern|
+            input = Array.new(num_inputs) { |k| pattern[k].to_f }
+            output = get_output(weights, input)
+            expected = pattern.last.to_f
+            error += (output - expected).abs
+            update_weights(num_inputs, weights, input, expected, output, lrate)
+          end
+          puts "> epoch=#{epoch}, error=#{error}"
+        end
+      end
 
-    def train_weights(weights, domain, num_inputs, iterations, lrate)
-      iterations.times do |epoch|
-        error = 0.0
+      def test_weights(weights, domain, num_inputs)
+        correct = 0
         domain.each do |pattern|
-          input = Array.new(num_inputs) { |k| pattern[k].to_f }
-          output = get_output(weights, input)
-          expected = pattern.last.to_f
-          error += (output - expected).abs
-          update_weights(num_inputs, weights, input, expected, output, lrate)
+          input_vector = Array.new(num_inputs) { |k| pattern[k].to_f }
+          output = get_output(weights, input_vector)
+          correct += 1 if output.round == pattern.last
         end
-        puts "> epoch=#{epoch}, error=#{error}"
+        puts "Finished test with a score of #{correct}/#{domain.size}"
+        correct
       end
-    end
 
-    def test_weights(weights, domain, num_inputs)
-      correct = 0
-      domain.each do |pattern|
-        input_vector = Array.new(num_inputs) { |k| pattern[k].to_f }
-        output = get_output(weights, input_vector)
-        correct += 1 if output.round == pattern.last
+      def execute(domain, num_inputs, iterations, learning_rate)
+        weights = initialize_weights(num_inputs)
+        train_weights(weights, domain, num_inputs, iterations, learning_rate)
+        test_weights(weights, domain, num_inputs)
+        weights
       end
-      puts "Finished test with a score of #{correct}/#{domain.size}"
-      correct
-    end
 
-    def execute(domain, num_inputs, iterations, learning_rate)
-      weights = initialize_weights(num_inputs)
-      train_weights(weights, domain, num_inputs, iterations, learning_rate)
-      test_weights(weights, domain, num_inputs)
-      weights
     end
 
   end
-
 end

data/lib/Algorithmically/Stochastic/adaptive_random_search.rb

@@ -1,82 +1,84 @@
-module Stochastic
+module Algorithmically
+  module Stochastic
 
-  class AdaptiveRandomSearch
+    class AdaptiveRandomSearch
 
-    def initialize(max_iter, bounds, init_factor, s_factor, l_factor, iter_mult, max_no_impr)
-      problem_size = bounds
-      @bounds1 = Array.new(problem_size) {|i| [-5, +5]}
-      @max_iter = max_iter
-      @init_factor = init_factor
-      @s_factor = s_factor
-      @l_factor = l_factor
-      @iter_mult = iter_mult
-      @max_no_impr = max_no_impr
-      @best = search(@max_iter, @bounds1, @init_factor, @s_factor, @l_factor, @iter_mult, @max_no_impr)
-      puts "Done. Best Solution: c=#{@best[:cost]}, v=#{@best[:vector].inspect}"
-    end
+      def initialize(max_iter, bounds, init_factor, s_factor, l_factor, iter_mult, max_no_impr)
+        problem_size = bounds
+        @bounds1 = Array.new(problem_size) { |i| [-5, +5] }
+        @max_iter = max_iter
+        @init_factor = init_factor
+        @s_factor = s_factor
+        @l_factor = l_factor
+        @iter_mult = iter_mult
+        @max_no_impr = max_no_impr
+        @best = search(@max_iter, @bounds1, @init_factor, @s_factor, @l_factor, @iter_mult, @max_no_impr)
+        puts "Done. Best Solution: c=#{@best[:cost]}, v=#{@best[:vector].inspect}"
+      end
 
-    def objective_function(vector)
-      vector.inject(0) { |sum, x| sum + (x ** 2.0) }
-    end
+      def objective_function(vector)
+        vector.inject(0) { |sum, x| sum + (x ** 2.0) }
+      end
 
-    def rand_in_bounds(min, max)
-      min + ((max-min) * rand())
-    end
+      def rand_in_bounds(min, max)
+        min + ((max-min) * rand())
+      end
 
-    def random_vector(minmax)
-      Array.new(minmax.size) do |i|
-        rand_in_bounds(minmax[i][0], minmax[i][1])
+      def random_vector(minmax)
+        Array.new(minmax.size) do |i|
+          rand_in_bounds(minmax[i][0], minmax[i][1])
+        end
       end
-    end
 
-    def take_step(minmax, current, step_size)
-      position = Array.new(current.size)
-      position.size.times do |i|
-        min = [minmax[i][0], current[i]-step_size].max
-        max = [minmax[i][1], current[i]+step_size].min
-        position[i] = rand_in_bounds(min, max)
+      def take_step(minmax, current, step_size)
+        position = Array.new(current.size)
+        position.size.times do |i|
+          min = [minmax[i][0], current[i]-step_size].max
+          max = [minmax[i][1], current[i]+step_size].min
+          position[i] = rand_in_bounds(min, max)
+        end
+        position
       end
-      position
-    end
 
-    def large_step_size(iter, step_size, s_factor, l_factor, iter_mult)
-      step_size * l_factor if iter > 0 and iter.modulo(iter_mult) == 0
-      step_size * s_factor
-    end
+      def large_step_size(iter, step_size, s_factor, l_factor, iter_mult)
+        step_size * l_factor if iter > 0 and iter.modulo(iter_mult) == 0
+        step_size * s_factor
+      end
 
-    def take_steps(bounds, current, step_size, big_stepsize)
-      step, big_step = {}, {}
-      step[:vector] = take_step(bounds, current[:vector], step_size)
-      step[:cost] = objective_function(step[:vector])
-      big_step[:vector] = take_step(bounds, current[:vector], big_stepsize)
-      big_step[:cost] = objective_function(big_step[:vector])
-      return step, big_step
-    end
+      def take_steps(bounds, current, step_size, big_stepsize)
+        step, big_step = {}, {}
+        step[:vector] = take_step(bounds, current[:vector], step_size)
+        step[:cost] = objective_function(step[:vector])
+        big_step[:vector] = take_step(bounds, current[:vector], big_stepsize)
+        big_step[:cost] = objective_function(big_step[:vector])
+        return step, big_step
+      end
 
-    def search(max_iter, bounds, init_factor, s_factor, l_factor, iter_mult, max_no_impr)
-      step_size = (bounds[0][1]-bounds[0][0]) * init_factor
-      current, count = {}, 0
-      current[:vector] = random_vector(bounds)
-      current[:cost] = objective_function(current[:vector])
-      max_iter.times do |iter|
-        big_stepsize = large_step_size(iter, step_size, s_factor, l_factor, iter_mult)
-        step, big_step = take_steps(bounds, current, step_size, big_stepsize)
-        if step[:cost] <= current[:cost] or big_step[:cost] <= current[:cost]
-          if big_step[:cost] <= step[:cost]
-            step_size, current = big_stepsize, big_step
+      def search(max_iter, bounds, init_factor, s_factor, l_factor, iter_mult, max_no_impr)
+        step_size = (bounds[0][1]-bounds[0][0]) * init_factor
+        current, count = {}, 0
+        current[:vector] = random_vector(bounds)
+        current[:cost] = objective_function(current[:vector])
+        max_iter.times do |iter|
+          big_stepsize = large_step_size(iter, step_size, s_factor, l_factor, iter_mult)
+          step, big_step = take_steps(bounds, current, step_size, big_stepsize)
+          if step[:cost] <= current[:cost] or big_step[:cost] <= current[:cost]
+            if big_step[:cost] <= step[:cost]
+              step_size, current = big_stepsize, big_step
+            else
+              current = step
+            end
+            count = 0
           else
-            current = step
+            count += 1
+            count, step_size = 0, (step_size/s_factor) if count >= max_no_impr
           end
-          count = 0
-        else
-          count += 1
-          count, step_size = 0, (step_size/s_factor) if count >= max_no_impr
+          puts " > iteration #{(iter+1)}, best=#{current[:cost]}"
         end
-        puts " > iteration #{(iter+1)}, best=#{current[:cost]}"
+        current
       end
-      current
+
     end
 
   end
-
 end

data/lib/Algorithmically/Stochastic/guided_local_search.rb

@@ -1,107 +1,109 @@
-module Stochastic
+module Algorithmically
+  module Stochastic
 
-  class GuidedLocalSearch
+    class GuidedLocalSearch
 
-    def initialize(max_iterations, berlin52, max_no_improv, lambda)
-      @berlin52 = berlin52
-      @max_iterations = max_iterations
-      @max_no_improv = max_no_improv
-      alpha = 0.3
-      local_search_optima = 12000.0
-      lambda = alpha * (local_search_optima/berlin52.size.to_f)
-      @lambda  = lambda
-      best = search(@max_iterations, @berlin52, @max_no_improv, lambda)
-      puts "Done. Best Solution: c=#{best[:cost]}, v=#{best[:vector].inspect}"
-    end
-
-    def euc_2d(c1, c2)
-      Math.sqrt((c1[0] - c2[0])**2.0 + (c1[1] - c2[1])**2.0).round
-    end
+      def initialize(max_iterations, berlin52, max_no_improv, lambda)
+        @berlin52 = berlin52
+        @max_iterations = max_iterations
+        @max_no_improv = max_no_improv
+        alpha = 0.3
+        local_search_optima = 12000.0
+        lambda = alpha * (local_search_optima/berlin52.size.to_f)
+        @lambda = lambda
+        best = search(@max_iterations, @berlin52, @max_no_improv, lambda)
+        puts "Done. Best Solution: c=#{best[:cost]}, v=#{best[:vector].inspect}"
+      end
 
-    def random_permutation(cities)
-      perm = Array.new(cities.size) { |i| i }
-      perm.each_index do |i|
-        r = rand(perm.size-i) + i
-        perm[r], perm[i] = perm[i], perm[r]
+      def euc_2d(c1, c2)
+        Math.sqrt((c1[0] - c2[0])**2.0 + (c1[1] - c2[1])**2.0).round
       end
-      perm
-    end
 
-    def stochastic_two_opt(permutation)
-      perm = Array.new(permutation)
-      c1, c2 = rand(perm.size), rand(perm.size)
-      exclude = [c1]
-      exclude << ((c1==0) ? perm.size-1 : c1-1)
-      exclude << ((c1==perm.size-1) ? 0 : c1+1)
-      c2 = rand(perm.size) while exclude.include?(c2)
-      c1, c2 = c2, c1 if c2 < c1
-      perm[c1...c2] = perm[c1...c2].reverse
-      perm
-    end
+      def random_permutation(cities)
+        perm = Array.new(cities.size) { |i| i }
+        perm.each_index do |i|
+          r = rand(perm.size-i) + i
+          perm[r], perm[i] = perm[i], perm[r]
+        end
+        perm
+      end
 
-    def augmented_cost(permutation, penalties, cities, lambda)
-      distance, augmented = 0, 0
-      permutation.each_with_index do |c1, i|
-        c2 = (i==permutation.size-1) ? permutation[0] : permutation[i+1]
+      def stochastic_two_opt(permutation)
+        perm = Array.new(permutation)
+        c1, c2 = rand(perm.size), rand(perm.size)
+        exclude = [c1]
+        exclude << ((c1==0) ? perm.size-1 : c1-1)
+        exclude << ((c1==perm.size-1) ? 0 : c1+1)
+        c2 = rand(perm.size) while exclude.include?(c2)
         c1, c2 = c2, c1 if c2 < c1
-        d = euc_2d(cities[c1], cities[c2])
-        distance += d
-        augmented += d + (lambda * (penalties[c1][c2]))
+        perm[c1...c2] = perm[c1...c2].reverse
+        perm
       end
-      [distance, augmented]
-    end
 
-    def cost(cand, penalties, cities, lambda)
-      cost, acost = augmented_cost(cand[:vector], penalties, cities, lambda)
-      cand[:cost], cand[:aug_cost] = cost, acost
-    end
+      def augmented_cost(permutation, penalties, cities, lambda)
+        distance, augmented = 0, 0
+        permutation.each_with_index do |c1, i|
+          c2 = (i==permutation.size-1) ? permutation[0] : permutation[i+1]
+          c1, c2 = c2, c1 if c2 < c1
+          d = euc_2d(cities[c1], cities[c2])
+          distance += d
+          augmented += d + (lambda * (penalties[c1][c2]))
+        end
+        [distance, augmented]
+      end
 
-    def local_search(current, cities, penalties, max_no_improv, lambda)
-      cost(current, penalties, cities, lambda)
-      count = 0
-      begin
-        candidate = {:vector => stochastic_two_opt(current[:vector])}
-        cost(candidate, penalties, cities, lambda)
-        count = (candidate[:aug_cost] < current[:aug_cost]) ? 0 : count+1
-        current = candidate if candidate[:aug_cost] < current[:aug_cost]
-      end until count >= max_no_improv
-      current
-    end
+      def cost(cand, penalties, cities, lambda)
+        cost, acost = augmented_cost(cand[:vector], penalties, cities, lambda)
+        cand[:cost], cand[:aug_cost] = cost, acost
+      end
 
-    def calculate_feature_utilities(penal, cities, permutation)
-      utilities = Array.new(permutation.size, 0)
-      permutation.each_with_index do |c1, i|
-        c2 = (i==permutation.size-1) ? permutation[0] : permutation[i+1]
-        c1, c2 = c2, c1 if c2 < c1
-        utilities[i] = euc_2d(cities[c1], cities[c2]) / (1.0 + penal[c1][c2])
+      def local_search(current, cities, penalties, max_no_improv, lambda)
+        cost(current, penalties, cities, lambda)
+        count = 0
+        begin
+          candidate = {:vector => stochastic_two_opt(current[:vector])}
+          cost(candidate, penalties, cities, lambda)
+          count = (candidate[:aug_cost] < current[:aug_cost]) ? 0 : count+1
+          current = candidate if candidate[:aug_cost] < current[:aug_cost]
+        end until count >= max_no_improv
+        current
       end
-      utilities
-    end
 
-    def update_penalties!(penalties, cities, permutation, utilities)
-      max = utilities.max()
-      permutation.each_with_index do |c1, i|
-        c2 = (i==permutation.size-1) ? permutation[0] : permutation[i+1]
-        c1, c2 = c2, c1 if c2 < c1
-        penalties[c1][c2] += 1 if utilities[i] == max
+      def calculate_feature_utilities(penal, cities, permutation)
+        utilities = Array.new(permutation.size, 0)
+        permutation.each_with_index do |c1, i|
+          c2 = (i==permutation.size-1) ? permutation[0] : permutation[i+1]
+          c1, c2 = c2, c1 if c2 < c1
+          utilities[i] = euc_2d(cities[c1], cities[c2]) / (1.0 + penal[c1][c2])
+        end
+        utilities
+      end
+
+      def update_penalties!(penalties, cities, permutation, utilities)
+        max = utilities.max()
+        permutation.each_with_index do |c1, i|
+          c2 = (i==permutation.size-1) ? permutation[0] : permutation[i+1]
+          c1, c2 = c2, c1 if c2 < c1
+          penalties[c1][c2] += 1 if utilities[i] == max
+        end
+        penalties
       end
-      penalties
-    end
 
-    def search(max_iterations, cities, max_no_improv, lambda)
-      current = {:vector => random_permutation(cities)}
-      best = nil
-      penalties = Array.new(cities.size) { Array.new(cities.size, 0) }
-      max_iterations.times do |iter|
-        current=local_search(current, cities, penalties, max_no_improv, lambda)
-        utilities=calculate_feature_utilities(penalties, cities, current[:vector])
-        update_penalties!(penalties, cities, current[:vector], utilities)
-        best = current if best.nil? or current[:cost] < best[:cost]
-        puts " > iter=#{(iter+1)}, best=#{best[:cost]}, aug=#{best[:aug_cost]}"
+      def search(max_iterations, cities, max_no_improv, lambda)
+        current = {:vector => random_permutation(cities)}
+        best = nil
+        penalties = Array.new(cities.size) { Array.new(cities.size, 0) }
+        max_iterations.times do |iter|
+          current=local_search(current, cities, penalties, max_no_improv, lambda)
+          utilities=calculate_feature_utilities(penalties, cities, current[:vector])
+          update_penalties!(penalties, cities, current[:vector], utilities)
+          best = current if best.nil? or current[:cost] < best[:cost]
+          puts " > iter=#{(iter+1)}, best=#{best[:cost]}, aug=#{best[:aug_cost]}"
+        end
+        best
       end
-      best
+
     end
 
   end
-
 end

data/lib/Algorithmically/Stochastic/hill_climbing.rb

@@ -1,42 +1,44 @@
-module Stochastic
+module Algorithmically
+  module Stochastic
 
-  class HillClimbing
+    class HillClimbing
 
-    def initialize(max_iterations, num_bits)
-      best = search(max_iterations, num_bits)
-      puts "Done. Best Solution: c=#{best[:cost]}, v=#{best[:vector].join}"
-    end
+      def initialize(max_iterations, num_bits)
+        best = search(max_iterations, num_bits)
+        puts "Done. Best Solution: c=#{best[:cost]}, v=#{best[:vector].join}"
+      end
 
-    def onemax(vector)
-      vector.inject(0.0) { |sum, v| sum + ((v=="1") ? 1 : 0) }
-    end
+      def onemax(vector)
+        vector.inject(0.0) { |sum, v| sum + ((v=="1") ? 1 : 0) }
+      end
 
-    def random_bitstring(num_bits)
-      Array.new(num_bits) { |i| (rand<0.5) ? "1" : "0" }
-    end
+      def random_bitstring(num_bits)
+        Array.new(num_bits) { |i| (rand<0.5) ? "1" : "0" }
+      end
 
-    def random_neighbor(bitstring)
-      mutant = Array.new(bitstring)
-      pos = rand(bitstring.size)
-      mutant[pos] = (mutant[pos]=='1') ? '0' : '1'
-      mutant
-    end
+      def random_neighbor(bitstring)
+        mutant = Array.new(bitstring)
+        pos = rand(bitstring.size)
+        mutant[pos] = (mutant[pos]=='1') ? '0' : '1'
+        mutant
+      end
 
-    def search(max_iterations, num_bits)
-      candidate = {}
-      candidate[:vector] = random_bitstring(num_bits)
-      candidate[:cost] = onemax(candidate[:vector])
-      max_iterations.times do |iter|
-        neighbor = {}
-        neighbor[:vector] = random_neighbor(candidate[:vector])
-        neighbor[:cost] = onemax(neighbor[:vector])
-        candidate = neighbor if neighbor[:cost] >= candidate[:cost]
-        puts " > iteration #{(iter+1)}, best=#{candidate[:cost]}"
-        break if candidate[:cost] == num_bits
+      def search(max_iterations, num_bits)
+        candidate = {}
+        candidate[:vector] = random_bitstring(num_bits)
+        candidate[:cost] = onemax(candidate[:vector])
+        max_iterations.times do |iter|
+          neighbor = {}
+          neighbor[:vector] = random_neighbor(candidate[:vector])
+          neighbor[:cost] = onemax(neighbor[:vector])
+          candidate = neighbor if neighbor[:cost] >= candidate[:cost]
+          puts " > iteration #{(iter+1)}, best=#{candidate[:cost]}"
+          break if candidate[:cost] == num_bits
+        end
+        candidate
       end
-      candidate
+
     end
 
   end
-
 end

data/lib/Algorithmically/Stochastic/random_search.rb

@@ -1,37 +1,39 @@
-module Stochastic
+module Algorithmically
+  module Stochastic
 
-  class RandomSearch
+    class RandomSearch
 
-    def initialize(size, max_iter)
-      problem_size = size
-      search_space = Array.new(problem_size) { |i| [-5, +5] }
-      maximum_iterations = max_iter
-      best_solution = self.search(search_space, maximum_iterations)
-      puts "Done. Best Solution: c = #{best_solution[:cost]}, v = #{best_solution[:vector].inspect}"
-    end
+      def initialize(size, max_iter)
+        problem_size = size
+        search_space = Array.new(problem_size) { |i| [-5, +5] }
+        maximum_iterations = max_iter
+        best_solution = self.search(search_space, maximum_iterations)
+        puts "Done. Best Solution: c = #{best_solution[:cost]}, v = #{best_solution[:vector].inspect}"
+      end
 
-    def objective_function(vector)
-      vector.inject(0) { |sum, x| sum + (x ** 2.0) }
-    end
+      def objective_function(vector)
+        vector.inject(0) { |sum, x| sum + (x ** 2.0) }
+      end
 
-    def random_vector(minmax)
-      Array.new(minmax.size) do |i|
-        minmax[i][0] + ((minmax[i][1]) - minmax[i][0] * rand())
+      def random_vector(minmax)
+        Array.new(minmax.size) do |i|
+          minmax[i][0] + ((minmax[i][1]) - minmax[i][0] * rand())
+        end
       end
-    end
 
-    def search(search_space, maximum_iterations)
-      best_solution = nil
-      maximum_iterations.times do |iterate|
-        search_candidate = {}
-        search_candidate[:vector] = random_vector(search_space)
-        search_candidate[:cost] = objective_function(search_candidate[:vector])
-        best_solution = search_candidate if best_solution.nil? or search_candidate[:cost] < best_solution[:cost]
-        puts " > iteration = #{(iterate + 1)}, best = #{best_solution[:cost]}"
+      def search(search_space, maximum_iterations)
+        best_solution = nil
+        maximum_iterations.times do |iterate|
+          search_candidate = {}
+          search_candidate[:vector] = random_vector(search_space)
+          search_candidate[:cost] = objective_function(search_candidate[:vector])
+          best_solution = search_candidate if best_solution.nil? or search_candidate[:cost] < best_solution[:cost]
+          puts " > iteration = #{(iterate + 1)}, best = #{best_solution[:cost]}"
+        end
+        best_solution
       end
-      best_solution
+
     end
 
   end
-
 end

data/lib/Algorithmically/version.rb

@@ -1,3 +1,3 @@
 module Algorithmically
-  VERSION = '0.1.5'
+  VERSION = '0.1.6'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: Algorithmically
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.6
 platform: ruby
 authors:
 - popac