app/services/tables/discomfort_calculator.rb

@@ -11,7 +11,6 @@ module Tables
     end
 
     def calculate
-      # Rails.logger.info "Calculating discomfort of table with id #{table.object_id}"
       breakdown.values.sum
     end
 

app/services/tables/distribution.rb

@@ -14,18 +14,17 @@ module Tables
 
     attr_accessor :tables, :min_per_table, :max_per_table, :hierarchy
 
-    def initialize(min_per_table:, max_per_table:, hierarchy: AffinityGroupsHierarchy.new)
+    def initialize(min_per_table:, max_per_table:)
       @min_per_table = min_per_table
       @max_per_table = max_per_table
-      @hierarchy = hierarchy
+      @hierarchy = AffinityGroupsHierarchy.new
       @tables = []
     end
 
-    def random_distribution(people, random: Random.new)
+    def random_distribution(people)
       min_tables = (people.count * 1.0 / @max_per_table).ceil
       max_tables = (people.count * 1.0 / @min_per_table).ceil
-      table_size = random.rand(min_tables..max_tables)
-      @tables = people.in_groups(table_size, false)
+      @tables = people.in_groups(rand(min_tables..max_tables), false)
                       .map { |group| Table.new(group) }
                       .each { |table| table.min_per_table = @min_per_table }
                       .each { |table| table.max_per_table = @max_per_table }
@@ -42,8 +41,7 @@ module Tables
     end
 
     def deep_dup
-      self.class.new(min_per_table: @min_per_table, max_per_table: @max_per_table,
-                     hierarchy: @hierarchy).tap do |new_distribution|
+      self.class.new(min_per_table: @min_per_table, max_per_table: @max_per_table).tap do |new_distribution|
         new_distribution.tables = @tables.map(&:dup)
       end
     end
@@ -73,8 +71,6 @@ module Tables
 
     def local_discomfort(table)
       table.discomfort ||= DiscomfortCalculator.new(table:, hierarchy:).calculate
-      table.freeze
-      table.discomfort 
     end
   end
 end

app/services/tables/shift.rb

@@ -12,37 +12,19 @@ module Tables
     def each
       @initial_solution.tables.permutation(2) do |table_a, table_b|
         table_a.dup.each do |person|
+          original_discomfort_a = table_a.reset
+          original_discomfort_b = table_b.reset
 
-          new_solution = Distribution.new(
-            min_per_table: @initial_solution.min_per_table,
-            max_per_table: @initial_solution.max_per_table,
-            hierarchy: @initial_solution.hierarchy
-          )
+          table_a.delete(person)
+          table_b << person
 
-          new_solution.tables = @initial_solution.tables.dup
+          yield(@initial_solution)
+        ensure
+          table_b.delete(person)
+          table_a << person
 
-          new_solution.tables.delete(table_a)
-          new_solution.tables.delete(table_b)
-
-          modified_table_a = table_a.dup.tap(&:reset)
-          modified_table_b = table_b.dup.tap(&:reset)
-
-          new_solution.tables << modified_table_a
-          new_solution.tables << modified_table_b
-
-          # original_discomfort_a = table_a.reset
-          # original_discomfort_b = table_b.reset
-
-          modified_table_a.delete(person)
-          modified_table_b << person
-
-          yield(new_solution)
-        # ensure
-        #   table_b.delete(person)
-        #   table_a << person
-
-        #   table_a.discomfort = original_discomfort_a
-        #   table_b.discomfort = original_discomfort_b
+          table_a.discomfort = original_discomfort_a
+          table_b.discomfort = original_discomfort_b
         end
       end
     end

app/services/tables/swap.rb

@@ -12,45 +12,25 @@ module Tables
     def each
       @initial_solution.tables.combination(2) do |table_a, table_b|
         table_a.to_a.product(table_b.to_a).each do |(person_a, person_b)|
+          original_discomfort_a = table_a.reset
+          original_discomfort_b = table_b.reset
 
-          new_solution = Distribution.new(
-            min_per_table: @initial_solution.min_per_table,
-            max_per_table: @initial_solution.max_per_table,
-            hierarchy: @initial_solution.hierarchy
-          )
+          table_a.delete(person_a)
+          table_b.delete(person_b)
 
-          new_solution.tables = @initial_solution.tables.dup
+          table_a << person_b
+          table_b << person_a
 
-          new_solution.tables.delete(table_a)
-          new_solution.tables.delete(table_b)
+          yield(@initial_solution)
+        ensure
+          table_a.delete(person_b)
+          table_b.delete(person_a)
 
+          table_a << person_a
+          table_b << person_b
 
-          modified_table_a = table_a.dup.tap(&:reset)
-          modified_table_b = table_b.dup.tap(&:reset)
-
-          new_solution.tables << modified_table_a
-          new_solution.tables << modified_table_b
-
-
-          # original_discomfort_a = table_a.reset
-          # original_discomfort_b = table_b.reset
-
-          modified_table_a.delete(person_a)
-          modified_table_b.delete(person_b)
-
-          modified_table_a << person_b
-          modified_table_b << person_a
-
-          yield(new_solution)
-        # ensure
-        #   table_a.delete(person_b)
-        #   table_b.delete(person_a)
-
-        #   table_a << person_a
-        #   table_b << person_b
-
-        #   table_a.discomfort = original_discomfort_a
-        #   table_b.discomfort = original_discomfort_b
+          table_a.discomfort = original_discomfort_a
+          table_b.discomfort = original_discomfort_b
         end
       end
     end

app/services/vns/engine.rb

@@ -20,16 +20,7 @@ module VNS
       @perturbations << klass
     end
 
-    def initialize_ractors(count: Concurrent.processor_count)
-      @ractors = count.times.map do |i|
-        Ractor.new(name: "VNS Ractor #{i}") do
-          # @target_function.call(Ractor.receive)
-          Ractor.receive.discomfort  # Hard-coded for now, should be dynamic
-        end
-      end.cycle
-    end
-
-    attr_writer :initial_solution, :ractors
+    attr_writer :initial_solution
 
     def run
       raise 'No target function defined' unless @target_function
@@ -39,10 +30,6 @@ module VNS
       @best_solution = @initial_solution
       @best_score = @target_function.call(@best_solution)
 
-      @best_solution.freeze
-      @best_solution.tables.freeze
-      # @best_solution.tables.each(&:freeze)
-
       self.class.sequence(@perturbations).each do |perturbation|
         optimize(perturbation)
       end
@@ -57,27 +44,9 @@ module VNS
         optimized = false
 
         perturbation_klass.new(@best_solution).each do |alternative_solution|
-          # original_score =
-
-          # ractor = @ractors.next
-          # Rails.logger.info("Processed by ractor #{ractor.name}")
-
-          # ractor.send(alternative_solution)
-
-          # new_score = ractor.take
-
-          # binding.pry if new_score != original_score
-
-          # score = new_score
-
           score = @target_function.call(alternative_solution)
-
-          # Rails.logger.info("Evaluating alternative solution with score: #{score}")
-          
           next if score >= @best_score
 
-          # Rails.logger.info("Found better solution with score: #{score} (previous: #{@best_score})")
-
           @best_solution = alternative_solution.deep_dup
           @best_score = score
           optimized = true

lib/tasks/vns.rake

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-namespace :vns do
-  desc 'Benchmarks the efficiency of the VNS implementation'
-  task benchmark: :environment do
-    ActsAsTenant.with_tenant(Wedding.first) do
-      Rails.logger.info "There are #{Guest.potential.count} potential guests"
-
-      engine = VNS::Engine.new
-
-      engine.add_perturbation(Tables::Swap)
-      engine.add_perturbation(Tables::Shift)
-
-      hierarchy = AffinityGroupsHierarchy.new
-      initial_solution = Tables::Distribution.new(min_per_table: 8, max_per_table: 10, hierarchy:)
-
-      random = Random.new(561_163)
-      initial_solution.random_distribution(Guest.potential.shuffle(random:), random:)
-
-      engine.initial_solution = initial_solution
-
-      engine.target_function(&:discomfort)
-
-      solution = Rails.benchmark('VNS Benchmarking') { engine.run }
-
-      Rails.logger.info "Best solution found with discomfort: #{solution.discomfort}"
-    end
-  end
-end