or-tools 0.1.3 → 0.3.1

data/lib/or_tools/bool_var.rb

@@ -0,0 +1,9 @@
+module ORTools
+  class BoolVar
+    include ComparisonOperators
+
+    def *(other)
+      SatLinearExpr.new([[self, other]])
+    end
+  end
+end

data/lib/or_tools/cp_solver.rb

@@ -12,11 +12,20 @@ module ORTools
     end
 
     def value(var)
-      _solution_integer_value(@response, var)
+      if var.is_a?(BoolVar)
+        _solution_boolean_value(@response, var)
+      else
+        _solution_integer_value(@response, var)
+      end
+    end
+
+    def solve_with_solution_callback(model, observer)
+      @response = _solve_with_observer(model, observer, false)
+      @response.status
     end
 
     def search_for_all_solutions(model, observer)
-      @response = _solve_with_observer(model, observer)
+      @response = _solve_with_observer(model, observer, true)
       @response.status
     end
   end

data/lib/or_tools/cp_solver_solution_callback.rb

@@ -12,5 +12,9 @@ module ORTools
         raise "Unsupported type"
       end
     end
+
+    def objective_value
+      @response.objective_value
+    end
   end
 end

data/lib/or_tools/linear_expr.rb

@@ -8,6 +8,14 @@ module ORTools
       end
     end
 
+    def >=(other)
+      if other.is_a?(LinearExpr)
+        _gte_linear_expr(other)
+      else
+        _gte_double(other)
+      end
+    end
+
     def <=(other)
       if other.is_a?(LinearExpr)
         _lte_linear_expr(other)

data/lib/or_tools/seating.rb

@@ -0,0 +1,115 @@
+module ORTools
+  class Seating
+    attr_reader :assignments, :people, :total_weight
+
+    def initialize(connections:, tables:, min_connections: 1)
+      @people = connections.flat_map { |c| c[:people] }.uniq
+
+      @connections_for = {}
+      @people.each do |person|
+        @connections_for[person] = {}
+      end
+      connections.each do |c|
+        c[:people].each_with_index do |person, i|
+          others = c[:people].dup
+          others.delete_at(i)
+          others.each do |other|
+            @connections_for[person][other] ||= 0
+            @connections_for[person][other] += c[:weight]
+          end
+        end
+      end
+
+      model = ORTools::CpModel.new
+      all_tables = tables.size.times.to_a
+
+      # decision variables
+      seats = {}
+      all_tables.each do |t|
+        people.each do |g|
+          seats[[t, g]] = model.new_bool_var("guest %s seats on table %i" % [g, t])
+        end
+      end
+
+      pairs = people.combination(2)
+
+      colocated = {}
+      pairs.each do |g1, g2|
+        colocated[[g1, g2]] = model.new_bool_var("guest %s seats with guest %s" % [g1, g2])
+      end
+
+      same_table = {}
+      pairs.each do |g1, g2|
+        all_tables.each do |t|
+          same_table[[g1, g2, t]] = model.new_bool_var("guest %s seats with guest %s on table %i" % [g1, g2, t])
+        end
+      end
+
+      # objective
+      objective = []
+      pairs.each do |g1, g2|
+        weight = @connections_for[g1][g2]
+        objective << colocated[[g1, g2]] * weight if weight
+      end
+      model.maximize(model.sum(objective))
+
+      # everybody seats at one table
+      people.each do |g|
+        model.add(model.sum(all_tables.map { |t| seats[[t, g]] }) == 1)
+      end
+
+      # tables have a max capacity
+      all_tables.each do |t|
+        model.add(model.sum(@people.map { |g| seats[[t, g]] }) <= tables[t])
+      end
+
+      # link colocated with seats
+      pairs.each do |g1, g2|
+        all_tables.each do |t|
+          # link same_table and seats
+          model.add_bool_or([seats[[t, g1]].not, seats[[t, g2]].not, same_table[[g1, g2, t]]])
+          model.add_implication(same_table[[g1, g2, t]], seats[[t, g1]])
+          model.add_implication(same_table[[g1, g2, t]], seats[[t, g2]])
+        end
+
+        # link colocated and same_table
+        model.add(model.sum(all_tables.map { |t| same_table[[g1, g2, t]] }) == colocated[[g1, g2]])
+      end
+
+      # min known neighbors rule
+      same_table_by_person = Hash.new { |hash, key| hash[key] = [] }
+      same_table.each do |(g1, g2, t), v|
+        next unless @connections_for[g1][g2]
+        same_table_by_person[g1] << v
+        same_table_by_person[g2] << v
+      end
+      same_table_by_person.each do |_, vars|
+        model.add(model.sum(vars) >= min_connections)
+      end
+
+      # solve
+      solver = ORTools::CpSolver.new
+      status = solver.solve(model)
+      raise Error, "No solution found" unless [:feasible, :optimal].include?(status)
+
+      # read solution
+      @assignments = {}
+      seats.each do |k, v|
+        if solver.value(v)
+          @assignments[k[1]] = k[0]
+        end
+      end
+      @total_weight = solver.objective_value
+    end
+
+    def assigned_tables
+      assignments.group_by { |_, v| v }.map { |k, v| [k, v.map(&:first)] }.sort_by(&:first).map(&:last)
+    end
+
+    def connections_for(person, same_table: false)
+      result = @connections_for[person]
+      result = result.select { |k, _| @assignments[k] == @assignments[person] } if same_table
+      result
+    end
+  end
+end

data/lib/or_tools/sudoku.rb

@@ -0,0 +1,132 @@
+module ORTools
+  class Sudoku
+    attr_reader :solution
+
+    def initialize(initial_grid, x: false, magic_square: false, anti_knight: false, anti_king: false, non_consecutive: false)
+      raise ArgumentError, "Grid must be 9x9" unless initial_grid.size == 9 && initial_grid.all? { |r| r.size == 9 }
+      raise ArgumentError, "Grid must contain values between 0 and 9" unless initial_grid.flatten(1).all? { |v| (0..9).include?(v) }
+
+      model = ORTools::CpModel.new
+
+      cell_size = 3
+      line_size = cell_size**2
+      line = (0...line_size).to_a
+      cell = (0...cell_size).to_a
+
+      grid = {}
+      line.each do |i|
+        line.each do |j|
+          grid[[i, j]] = model.new_int_var(1, line_size, "grid %i %i" % [i, j])
+        end
+      end
+
+      line.each do |i|
+        model.add_all_different(line.map { |j| grid[[i, j]] })
+      end
+
+      line.each do |j|
+        model.add_all_different(line.map { |i| grid[[i, j]] })
+      end
+
+      cell.each do |i|
+        cell.each do |j|
+          one_cell = []
+          cell.each do |di|
+            cell.each do |dj|
+              one_cell << grid[[i * cell_size + di, j * cell_size + dj]]
+            end
+          end
+          model.add_all_different(one_cell)
+        end
+      end
+
+      line.each do |i|
+        line.each do |j|
+          if initial_grid[i][j] != 0
+            model.add(grid[[i, j]] == initial_grid[i][j])
+          end
+        end
+      end
+
+      if x
+        model.add_all_different(9.times.map { |i| grid[[i, i]] })
+        model.add_all_different(9.times.map { |i| grid[[i, 8 - i]] })
+      end
+
+      if magic_square
+        magic_sums = []
+        3.times do |i|
+          magic_sums << model.sum(3.times.map { |j| grid[[3 + i, 3 + j]] })
+          magic_sums << model.sum(3.times.map { |j| grid[[3 + j, 3 + i]] })
+        end
+
+        magic_sums << model.sum(3.times.map { |i| grid[[3 + i, 3 + i]] })
+        magic_sums << model.sum(3.times.map { |i| grid[[3 + i, 5 - i]] })
+
+        first_sum = magic_sums.shift
+        magic_sums.each do |magic_sum|
+          model.add(magic_sum == first_sum)
+        end
+      end
+
+      if anti_knight
+        # add anti-knights rule
+        # for each square, add squares that cannot be feasible
+        moves = [[1, 2], [2, 1], [2, -1], [1, -2], [-1, -2], [-2, -1], [-2, 1], [-1, 2]]
+        9.times do |i|
+          9.times do |j|
+            moves.each do |mi, mj|
+              square = grid[[i + mi, j + mj]]
+              if square
+                model.add(grid[[i, j]] != square)
+              end
+            end
+          end
+        end
+      end
+
+      if anti_king
+        # add anti-king rule
+        # for each square, add squares that cannot be feasible
+        moves = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+        9.times do |i|
+          9.times do |j|
+            moves.each do |mi, mj|
+              square = grid[[i + mi, j + mj]]
+              if square
+                model.add(grid[[i, j]] != square)
+              end
+            end
+          end
+        end
+      end
+
+      if non_consecutive
+        # add non-consecutive rule
+        # for each square, add squares that cannot be feasible
+        moves = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+        9.times do |i|
+          9.times do |j|
+            moves.each do |mi, mj|
+              square = grid[[i + mi, j + mj]]
+              if square
+                model.add(grid[[i, j]] + 1 != square)
+                model.add(grid[[i, j]] - 1 != square)
+              end
+            end
+          end
+        end
+      end
+
+      solver = ORTools::CpSolver.new
+      status = solver.solve(model)
+      raise Error, "No solution found" unless [:feasible, :optimal].include?(status)
+
+      solution = []
+      line.each do |i|
+        solution << line.map { |j| solver.value(grid[[i, j]]) }
+      end
+      @solution = solution
+    end
+  end
+end

data/lib/or_tools/tsp.rb

@@ -0,0 +1,60 @@
+module ORTools
+  class TSP
+    attr_reader :route, :route_indexes, :distances, :total_distance
+
+    DISTANCE_SCALE = 1000
+    DEGREES_TO_RADIANS = Math::PI / 180
+
+    def initialize(locations)
+      raise ArgumentError, "Locations must have latitude and longitude" unless locations.all? { |l| l[:latitude] && l[:longitude] }
+      raise ArgumentError, "Latitude must be between -90 and 90" unless locations.all? { |l| l[:latitude] >= -90 && l[:latitude] <= 90 }
+      raise ArgumentError, "Longitude must be between -180 and 180" unless locations.all? { |l| l[:longitude] >= -180 && l[:longitude] <= 180 }
+      raise ArgumentError, "Must be at least two locations" unless locations.size >= 2
+
+      distance_matrix =
+        locations.map do |from|
+          locations.map do |to|
+            # must be integers
+            (distance(from, to) * DISTANCE_SCALE).to_i
+          end
+        end
+
+      manager = ORTools::RoutingIndexManager.new(locations.size, 1, 0)
+      routing = ORTools::RoutingModel.new(manager)
+
+      distance_callback = lambda do |from_index, to_index|
+        from_node = manager.index_to_node(from_index)
+        to_node = manager.index_to_node(to_index)
+        distance_matrix[from_node][to_node]
+      end
+
+      transit_callback_index = routing.register_transit_callback(distance_callback)
+      routing.set_arc_cost_evaluator_of_all_vehicles(transit_callback_index)
+      assignment = routing.solve(first_solution_strategy: :path_cheapest_arc)
+
+      @route_indexes = []
+      @distances = []
+
+      index = routing.start(0)
+      while !routing.end?(index)
+        @route_indexes << manager.index_to_node(index)
+        previous_index = index
+        index = assignment.value(routing.next_var(index))
+        @distances << routing.arc_cost_for_vehicle(previous_index, index, 0) / DISTANCE_SCALE.to_f
+      end
+      @route_indexes << manager.index_to_node(index)
+      @route = locations.values_at(*@route_indexes)
+      @total_distance = @distances.sum
+    end
+
+    private
+
+    def distance(from, to)
+      from_lat = from[:latitude] * DEGREES_TO_RADIANS
+      from_lng = from[:longitude] * DEGREES_TO_RADIANS
+      to_lat = to[:latitude] * DEGREES_TO_RADIANS
+      to_lng = to[:longitude] * DEGREES_TO_RADIANS
+      2 * 6371 * Math.asin(Math.sqrt(Math.sin((to_lat - from_lat) / 2.0)**2 + Math.cos(from_lat) * Math.cos(to_lat) * Math.sin((from_lng - to_lng) / 2.0)**2))
+    end
+  end
+end

data/lib/or_tools/version.rb

@@ -1,3 +1,3 @@
 module ORTools
-  VERSION = "0.1.3"
+  VERSION = "0.3.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: or-tools
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.3.1
 platform: ruby
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-24 00:00:00.000000000 Z
+date: 2020-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rice
@@ -93,20 +93,25 @@ files:
 - README.md
 - ext/or-tools/ext.cpp
 - ext/or-tools/extconf.rb
+- ext/or-tools/vendor.rb
 - lib/or-tools.rb
+- lib/or_tools/basic_scheduler.rb
+- lib/or_tools/bool_var.rb
 - lib/or_tools/comparison.rb
 - lib/or_tools/comparison_operators.rb
 - lib/or_tools/cp_model.rb
 - lib/or_tools/cp_solver.rb
 - lib/or_tools/cp_solver_solution_callback.rb
-- lib/or_tools/ext.bundle
 - lib/or_tools/int_var.rb
 - lib/or_tools/knapsack_solver.rb
 - lib/or_tools/linear_expr.rb
 - lib/or_tools/routing_model.rb
 - lib/or_tools/sat_int_var.rb
 - lib/or_tools/sat_linear_expr.rb
+- lib/or_tools/seating.rb
 - lib/or_tools/solver.rb
+- lib/or_tools/sudoku.rb
+- lib/or_tools/tsp.rb
 - lib/or_tools/version.rb
 homepage: https://github.com/ankane/or-tools
 licenses: