or-tools 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4377b9acdd93be666c700e05fb56cf01e59f088cf149f345ab888ef018c82d04
-  data.tar.gz: f32d95eb857cf479db372f4c0c27b18590bb9137aa72a9b6e478789830b7ea68
+  metadata.gz: 18b9ab384a5aa4b8d27a3415de9ba751085e63b95cbdc431d1fee206b05e1c37
+  data.tar.gz: 4b8d29c3f6b5fff8181a817737a818e2c3d7cf6cd0184d82078d4606c2c94740
 SHA512:
-  metadata.gz: ab952c566d3f84c57cce0b843c27ad6e3fa9c06f4e85b273af2c82564403cd6bb88e8f8ae1d39c21f5732e4d3415729b8d4bd87418a34f0d02c588d816ab9d49
-  data.tar.gz: 95a03e432680341c029e21ae2148385c1628a7df127ea8707991a47d087f37cd5ebb4288518f16b1cfd7c84c03a254c0cf8c26c5c8d574b949c3ed3901ca9cfe
+  metadata.gz: 26e5b155bdd5c0d37aaf13fe26c674ac15ac693933999056a477e340823ced7e86b8565c00c941d4ecdfd35e0b5a4716465e2418bf1e44ca7c1586d171e77515
+  data.tar.gz: 1c87b6df5082d9ab61b1ab63d154e563fdd9405fa3dda5fd00df2f6aafc65c7f5f8d251938cab9cba58de04efb7f38b11893701c128833059b8290b3a3dfb0da

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 0.3.0 (2020-07-21)
+
+- Updated OR-Tools to 7.7
+- Added `BasicScheduler` class
+- Added `Seating` class
+- Added `TSP` class
+- Added `Sudoku` class
+
 ## 0.2.0 (2020-05-22)
 
 - No longer need to download the OR-Tools C++ library separately on Mac, Ubuntu 18.04, Ubuntu 16.04, Debian 10, and CentOS 8

data/README.md

@@ -14,12 +14,253 @@ gem 'or-tools'
 
 Installation can take a few minutes as OR-Tools downloads and builds.
 
-## Getting Started
+## Higher Level Interfaces
+
+- [Scheduling](#scheduling)
+- [Seating](#seating)
+- [Traveling Salesperson Problem (TSP)](#traveling-salesperson-problem-tsp)
+- [Sudoku](#sudoku)
+
+### Scheduling
+
+Specify people and their availabililty
+
+```ruby
+people = [
+  {
+    availability: [
+      {starts_at: Time.parse("2020-01-01 08:00:00"), ends_at: Time.parse("2020-01-01 16:00:00")},
+      {starts_at: Time.parse("2020-01-02 08:00:00"), ends_at: Time.parse("2020-01-02 16:00:00")}
+    ],
+    max_hours: 40 # optional, applies to entire scheduling period
+  },
+  {
+    availability: [
+      {starts_at: Time.parse("2020-01-01 08:00:00"), ends_at: Time.parse("2020-01-01 16:00:00")},
+      {starts_at: Time.parse("2020-01-03 08:00:00"), ends_at: Time.parse("2020-01-03 16:00:00")}
+    ],
+    max_hours: 20
+  }
+]
+```
+
+Specify shifts
+
+```ruby
+shifts = [
+  {starts_at: Time.parse("2020-01-01 08:00:00"), ends_at: Time.parse("2020-01-01 16:00:00")},
+  {starts_at: Time.parse("2020-01-02 08:00:00"), ends_at: Time.parse("2020-01-02 16:00:00")},
+  {starts_at: Time.parse("2020-01-03 08:00:00"), ends_at: Time.parse("2020-01-03 16:00:00")}
+]
+```
+
+Run the scheduler
+
+```ruby
+scheduler = ORTools::BasicScheduler.new(people: people, shifts: shifts)
+```
+
+The scheduler maximizes the number of assigned hours. A person must be available for the entire shift to be considered for it.
+
+Get assignments (returns indexes of people and shifts)
+
+```ruby
+scheduler.assignments
+# [
+#   {person: 2, shift: 0},
+#   {person: 0, shift: 1},
+#   {person: 1, shift: 2}
+# ]
+```
+
+Get assigned hours and total hours
+
+```ruby
+scheduler.assigned_hours
+scheduler.total_hours
+```
+
+Feel free to create an issue if you have a scheduling use case that’s not covered.
+
+### Seating
+
+Create a seating chart based on personal connections. Uses [this approach](https://www.improbable.com/news/2012/Optimal-seating-chart.pdf).
+
+Specify connections
+
+```ruby
+connections = [
+  {people: ["A", "B", "C"], weight: 2},
+  {people: ["C", "D", "E", "F"], weight: 1}
+]
+```
+
+Use different weights to prioritize seating. For a wedding, it may look like:
+
+```ruby
+connections = [
+  {people: knows_partner1, weight: 1},
+  {people: knows_partner2, weight: 1},
+  {people: relationship1, weight: 100},
+  {people: relationship2, weight: 100},
+  {people: relationship3, weight: 100},
+  {people: friend_group1, weight: 10},
+  {people: friend_group2, weight: 10},
+  # ...
+]
+```
+
+If two people have multiple connections, weights are added.
+
+Specify tables and their capacity
+
+```ruby
+tables = [3, 3]
+```
+
+Assign seats
+
+```ruby
+seating = ORTools::Seating.new(connections: connections, tables: tables)
+```
+
+Each person will have a connection with at least one other person at their table.
+
+Get tables
+
+```ruby
+seating.assigned_tables
+```
+
+Get assignments by person
+
+```ruby
+seating.assignments
+```
+
+Get all connections for a person
+
+```ruby
+seating.connections_for(person)
+```
+
+Get connections for a person at their table
+
+```ruby
+seating.connections_for(person, same_table: true)
+```
+
+### Traveling Salesperson Problem (TSP)
+
+Create locations - the first location will be the starting and ending point
+
+```ruby
+locations = [
+  {name: "Tokyo", latitude: 35.6762, longitude: 139.6503},
+  {name: "Delhi", latitude: 28.7041, longitude: 77.1025},
+  {name: "Shanghai", latitude: 31.2304, longitude: 121.4737},
+  {name: "São Paulo", latitude: -23.5505, longitude: -46.6333},
+  {name: "Mexico City", latitude: 19.4326, longitude: -99.1332},
+  {name: "Cairo", latitude: 30.0444, longitude: 31.2357},
+  {name: "Mumbai", latitude: 19.0760, longitude: 72.8777},
+  {name: "Beijing", latitude: 39.9042, longitude: 116.4074},
+  {name: "Dhaka", latitude: 23.8103, longitude: 90.4125},
+  {name: "Osaka", latitude: 34.6937, longitude: 135.5023},
+  {name: "New York City", latitude: 40.7128, longitude: -74.0060},
+  {name: "Karachi", latitude: 24.8607, longitude: 67.0011},
+  {name: "Buenos Aires", latitude: -34.6037, longitude: -58.3816}
+]
+```
+
+Locations can have any fields - only `latitude` and `longitude` are required
+
+Get route
+
+```ruby
+tsp = ORTools::TSP.new(locations)
+tsp.route # [{name: "Tokyo", ...}, {name: "Osaka", ...}, ...]
+```
+
+Get distances between locations on route
+
+```ruby
+tsp.distances # [392.441, 1362.926, 1067.31, ...]
+```
+
+Distances are in kilometers - multiply by `0.6214` for miles
+
+Get total distance
+
+```ruby
+tsp.total_distance
+```
+
+### Sudoku
+
+Create a puzzle with zeros in empty cells
+
+```ruby
+grid = [
+  [0, 6, 0, 0, 5, 0, 0, 2, 0],
+  [0, 0, 0, 3, 0, 0, 0, 9, 0],
+  [7, 0, 0, 6, 0, 0, 0, 1, 0],
+  [0, 0, 6, 0, 3, 0, 4, 0, 0],
+  [0, 0, 4, 0, 7, 0, 1, 0, 0],
+  [0, 0, 5, 0, 9, 0, 8, 0, 0],
+  [0, 4, 0, 0, 0, 1, 0, 0, 6],
+  [0, 3, 0, 0, 0, 8, 0, 0, 0],
+  [0, 2, 0, 0, 4, 0, 0, 5, 0]
+]
+sudoku = ORTools::Sudoku.new(grid)
+sudoku.solution
+```
+
+It can also solve more advanced puzzles like [The Miracle](https://www.youtube.com/watch?v=yKf9aUIxdb4)
+
+```ruby
+grid = [
+  [0, 0, 0, 0, 0, 0, 0, 0, 0],
+  [0, 0, 0, 0, 0, 0, 0, 0, 0],
+  [0, 0, 0, 0, 0, 0, 0, 0, 0],
+  [0, 0, 0, 0, 0, 0, 0, 0, 0],
+  [0, 0, 1, 0, 0, 0, 0, 0, 0],
+  [0, 0, 0, 0, 0, 0, 2, 0, 0],
+  [0, 0, 0, 0, 0, 0, 0, 0, 0],
+  [0, 0, 0, 0, 0, 0, 0, 0, 0],
+  [0, 0, 0, 0, 0, 0, 0, 0, 0]
+]
+sudoku = ORTools::Sudoku.new(grid, anti_knight: true, anti_king: true, non_consecutive: true)
+sudoku.solution
+```
+
+And [this 4-digit puzzle](https://www.youtube.com/watch?v=hAyZ9K2EBF0)
+
+```ruby
+grid = [
+  [0, 0, 0, 0, 0, 0, 0, 0, 0],
+  [0, 0, 0, 0, 0, 0, 0, 0, 0],
+  [0, 0, 0, 0, 0, 0, 0, 0, 0],
+  [3, 8, 4, 0, 0, 0, 0, 0, 0],
+  [0, 0, 0, 0, 0, 0, 0, 0, 0],
+  [0, 0, 0, 0, 0, 0, 0, 0, 0],
+  [0, 0, 0, 0, 0, 0, 0, 0, 0],
+  [0, 0, 0, 0, 0, 0, 0, 0, 0],
+  [0, 0, 0, 0, 0, 0, 0, 0, 2]
+]
+sudoku = ORTools::Sudoku.new(grid, x: true, anti_knight: true, magic_square: true)
+sudoku.solution
+```
+
+## Guides
 
 Linear Optimization
 
 - [The Glop Linear Solver](#the-glop-linear-solver)
 
+Integer Optimization
+
+- [Mixed-Integer Programming](#mixed-integer-programming)
+
 Constraint Optimization
 
 - [CP-SAT Solver](#cp-sat-solver)
@@ -27,13 +268,14 @@ Constraint Optimization
 - [Cryptarithmetic](#cryptarithmetic)
 - [The N-queens Problem](#the-n-queens-problem)
 
-Integer Optimization
+Assignment
 
-- [Mixed-Integer Programming](#mixed-integer-programming)
+- [Assignment](#assignment)
+- [Assignment with Teams](#assignment-with-teams)
 
 Routing
 
-- [Traveling Salesperson Problem (TSP)](#traveling-salesperson-problem-tsp)
+- [Traveling Salesperson Problem (TSP)](#traveling-salesperson-problem-tsp-1)
 - [Vehicle Routing Problem (VRP)](#vehicle-routing-problem-vrp)
 - [Capacity Constraints](#capacity-constraints)
 - [Pickups and Deliveries](#pickups-and-deliveries)
@@ -52,12 +294,7 @@ Network Flows
 
 - [Maximum Flows](#maximum-flows)
 - [Minimum Cost Flows](#minimum-cost-flows)
-
-Assignment
-
-- [Assignment](#assignment)
-- [Assignment as a Min Cost Problem](#assignment-as-a-min-cost-problem)
-- [Assignment as a MIP Problem](#assignment-as-a-mip-problem)
+- [Assignment as a Min Cost Flow Problem](#assignment-as-a-min-cost-flow-problem)
 
 Scheduling
 
@@ -66,7 +303,7 @@ Scheduling
 
 Other Examples
 
-- [Sudoku](#sudoku)
+- [Sudoku](#sudoku-1)
 - [Wedding Seating Chart](#wedding-seating-chart)
 - [Set Partitioning](#set-partitioning)
 
@@ -114,6 +351,52 @@ puts "y = #{y.solution_value}"
 puts "Optimal objective value = #{opt_solution}"
 ```
 
+### Mixed-Integer Programming
+
+[Guide](https://developers.google.com/optimization/mip/integer_opt)
+
+```ruby
+# declare the MIP solver
+solver = ORTools::Solver.new("simple_mip_program", :cbc)
+
+# define the variables
+infinity = solver.infinity
+x = solver.int_var(0.0, infinity, "x")
+y = solver.int_var(0.0, infinity, "y")
+
+puts "Number of variables = #{solver.num_variables}"
+
+# define the constraints
+c0 = solver.constraint(-infinity, 17.5)
+c0.set_coefficient(x, 1)
+c0.set_coefficient(y, 7)
+
+c1 = solver.constraint(-infinity, 3.5)
+c1.set_coefficient(x, 1);
+c1.set_coefficient(y, 0);
+
+puts "Number of constraints = #{solver.num_constraints}"
+
+# define the objective
+objective = solver.objective
+objective.set_coefficient(x, 1)
+objective.set_coefficient(y, 10)
+objective.set_maximization
+
+# call the solver
+status = solver.solve
+
+# display the solution
+if status == :optimal
+  puts "Solution:"
+  puts "Objective value = #{solver.objective.value}"
+  puts "x = #{x.solution_value}"
+  puts "y = #{y.solution_value}"
+else
+  puts "The problem does not have an optimal solution."
+end
+```
+
 ### CP-SAT Solver
 
 [Guide](https://developers.google.com/optimization/cp/cp_solver)
@@ -136,7 +419,7 @@ solver = ORTools::CpSolver.new
 status = solver.solve(model)
 
 # display the first solution
-if status == :feasible
+if status == :optimal
   puts "x = #{solver.value(x)}"
   puts "y = #{solver.value(y)}"
   puts "z = #{solver.value(z)}"
@@ -295,50 +578,119 @@ puts
 puts "Solutions found : %i" % solution_printer.solution_count
 ```
 
-### Mixed-Integer Programming
 
-[Guide](https://developers.google.com/optimization/mip/integer_opt)
+### Assignment
+
+[Guide](https://developers.google.com/optimization/assignment/assignment_example)
 
 ```ruby
-# declare the MIP solver
-solver = ORTools::Solver.new("simple_mip_program", :cbc)
+# create the data
+cost = [[ 90,  76, 75,  70],
+        [ 35,  85, 55,  65],
+        [125,  95, 90, 105],
+        [ 45, 110, 95, 115]]
 
-# define the variables
-infinity = solver.infinity
-x = solver.int_var(0.0, infinity, "x")
-y = solver.int_var(0.0, infinity, "y")
+rows = cost.length
+cols = cost[0].length
 
-puts "Number of variables = #{solver.num_variables}"
+# create the solver
+assignment = ORTools::LinearSumAssignment.new
 
-# define the constraints
-c0 = solver.constraint(-infinity, 17.5)
-c0.set_coefficient(x, 1)
-c0.set_coefficient(y, 7)
+# add the costs to the solver
+rows.times do |worker|
+  cols.times do |task|
+    if cost[worker][task]
+      assignment.add_arc_with_cost(worker, task, cost[worker][task])
+    end
+  end
+end
 
-c1 = solver.constraint(-infinity, 3.5)
-c1.set_coefficient(x, 1);
-c1.set_coefficient(y, 0);
+# invoke the solver
+solve_status = assignment.solve
+if solve_status == :optimal
+  puts "Total cost = #{assignment.optimal_cost}"
+  puts
+  assignment.num_nodes.times do |i|
+    puts "Worker %d assigned to task %d.  Cost = %d" % [
+      i,
+      assignment.right_mate(i),
+      assignment.assignment_cost(i)
+    ]
+  end
+elsif solve_status == :infeasible
+  puts "No assignment is possible."
+elsif solve_status == :possible_overflow
+  puts "Some input costs are too large and may cause an integer overflow."
+end
+```
 
-puts "Number of constraints = #{solver.num_constraints}"
+### Assignment with Teams
 
-# define the objective
-objective = solver.objective
-objective.set_coefficient(x, 1)
-objective.set_coefficient(y, 10)
-objective.set_maximization
+[Guide](https://developers.google.com/optimization/assignment/assignment_teams)
 
-# call the solver
-status = solver.solve
+```ruby
+# create the solver
+solver = ORTools::Solver.new("SolveAssignmentProblemMIP", :cbc)
 
-# display the solution
-if status == :optimal
-  puts "Solution:"
-  puts "Objective value = #{solver.objective.value}"
-  puts "x = #{x.solution_value}"
-  puts "y = #{y.solution_value}"
-else
-  puts "The problem does not have an optimal solution."
+# create the data
+cost = [[90, 76, 75, 70],
+        [35, 85, 55, 65],
+        [125, 95, 90, 105],
+        [45, 110, 95, 115],
+        [60, 105, 80, 75],
+        [45, 65, 110, 95]]
+
+team1 = [0, 2, 4]
+team2 = [1, 3, 5]
+team_max = 2
+
+# create the variables
+num_workers = cost.length
+num_tasks = cost[1].length
+x = {}
+
+num_workers.times do |i|
+  num_tasks.times do |j|
+    x[[i, j]] = solver.bool_var("x[#{i},#{j}]")
+  end
 end
+
+# create the objective function
+solver.minimize(solver.sum(
+  num_workers.times.flat_map { |i| num_tasks.times.map { |j| x[[i, j]] * cost[i][j] } }
+))
+
+# create the constraints
+num_workers.times do |i|
+  solver.add(solver.sum(num_tasks.times.map { |j| x[[i, j]] }) <= 1)
+end
+
+num_tasks.times do |j|
+  solver.add(solver.sum(num_workers.times.map { |i| x[[i, j]] }) == 1)
+end
+
+solver.add(solver.sum(team1.flat_map { |i| num_tasks.times.map { |j| x[[i, j]] } }) <= team_max)
+solver.add(solver.sum(team2.flat_map { |i| num_tasks.times.map { |j| x[[i, j]] } }) <= team_max)
+
+# invoke the solver
+sol = solver.solve
+
+puts "Total cost = #{solver.objective.value}"
+puts
+num_workers.times do |i|
+  num_tasks.times do |j|
+    if x[[i, j]].solution_value > 0
+      puts "Worker %d assigned to task %d.  Cost = %d" % [
+        i,
+        j,
+        cost[i][j]
+      ]
+    end
+  end
+end
+
+puts
+puts "Time = #{solver.wall_time} milliseconds"
 ```
 
 ### Traveling Salesperson Problem (TSP)
@@ -380,7 +732,7 @@ transit_callback_index = routing.register_transit_callback(distance_callback)
 routing.set_arc_cost_evaluator_of_all_vehicles(transit_callback_index)
 
 # run the solver
-assignment = routing.solve(first_solution_strategy: :path_cheaper_arc)
+assignment = routing.solve(first_solution_strategy: :path_cheapest_arc)
 
 # print the solution
 puts "Objective: #{assignment.objective_value} miles"
@@ -1276,52 +1628,7 @@ else
 end
 ```
 
-### Assignment
-
-[Guide](https://developers.google.com/optimization/assignment/simple_assignment)
-
-```ruby
-# create the data
-cost = [[ 90,  76, 75,  70],
-        [ 35,  85, 55,  65],
-        [125,  95, 90, 105],
-        [ 45, 110, 95, 115]]
-
-rows = cost.length
-cols = cost[0].length
-
-# create the solver
-assignment = ORTools::LinearSumAssignment.new
-
-# add the costs to the solver
-rows.times do |worker|
-  cols.times do |task|
-    if cost[worker][task]
-      assignment.add_arc_with_cost(worker, task, cost[worker][task])
-    end
-  end
-end
-
-# invoke the solver
-solve_status = assignment.solve
-if solve_status == :optimal
-  puts "Total cost = #{assignment.optimal_cost}"
-  puts
-  assignment.num_nodes.times do |i|
-    puts "Worker %d assigned to task %d.  Cost = %d" % [
-      i,
-      assignment.right_mate(i),
-      assignment.assignment_cost(i)
-    ]
-  end
-elsif solve_status == :infeasible
-  puts "No assignment is possible."
-elsif solve_status == :possible_overflow
-  puts "Some input costs are too large and may cause an integer overflow."
-end
-```
-
-### Assignment as a Min Cost Problem
+### Assignment as a Min Cost Flow Problem
 
 [Guide](https://developers.google.com/optimization/assignment/assignment_min_cost_flow)
 
@@ -1370,75 +1677,6 @@ else
 end
 ```
 
-### Assignment as a MIP Problem
-
-[Guide](https://developers.google.com/optimization/assignment/assignment_mip)
-
-```ruby
-# create the solver
-solver = ORTools::Solver.new("SolveAssignmentProblemMIP", :cbc)
-
-# create the data
-cost = [[90, 76, 75, 70],
-        [35, 85, 55, 65],
-        [125, 95, 90, 105],
-        [45, 110, 95, 115],
-        [60, 105, 80, 75],
-        [45, 65, 110, 95]]
-
-team1 = [0, 2, 4]
-team2 = [1, 3, 5]
-team_max = 2
-
-# create the variables
-num_workers = cost.length
-num_tasks = cost[1].length
-x = {}
-
-num_workers.times do |i|
-  num_tasks.times do |j|
-    x[[i, j]] = solver.bool_var("x[#{i},#{j}]")
-  end
-end
-
-# create the objective function
-solver.minimize(solver.sum(
-  num_workers.times.flat_map { |i| num_tasks.times.map { |j| x[[i, j]] * cost[i][j] } }
-))
-
-# create the constraints
-num_workers.times do |i|
-  solver.add(solver.sum(num_tasks.times.map { |j| x[[i, j]] }) <= 1)
-end
-
-num_tasks.times do |j|
-  solver.add(solver.sum(num_workers.times.map { |i| x[[i, j]] }) == 1)
-end
-
-solver.add(solver.sum(team1.flat_map { |i| num_tasks.times.map { |j| x[[i, j]] } }) <= team_max)
-solver.add(solver.sum(team2.flat_map { |i| num_tasks.times.map { |j| x[[i, j]] } }) <= team_max)
-
-# invoke the solver
-sol = solver.solve
-
-puts "Total cost = #{solver.objective.value}"
-puts
-num_workers.times do |i|
-  num_tasks.times do |j|
-    if x[[i, j]].solution_value > 0
-      puts "Worker %d assigned to task %d.  Cost = %d" % [
-        i,
-        j,
-        cost[i][j]
-      ]
-    end
-  end
-end
-
-puts
-puts "Time = #{solver.wall_time} milliseconds"
-```
-
 ### Employee Scheduling
 
 [Guide](https://developers.google.com/optimization/scheduling/employee_scheduling)
@@ -1710,7 +1948,7 @@ end
 # solve and print solution
 solver = ORTools::CpSolver.new
 status = solver.solve(model)
-if status == :feasible
+if status == :optimal
   line.each do |i|
     p line.map { |j| solver.value(grid[[i, j]]) }
   end
@@ -1725,8 +1963,8 @@ end
 # From
 # Meghan L. Bellows and J. D. Luc Peterson
 # "Finding an optimal seating chart for a wedding"
-# http://www.improbable.com/news/2012/Optimal-seating-chart.pdf
-# http://www.improbable.com/2012/02/12/finding-an-optimal-seating-chart-for-a-wedding
+# https://www.improbable.com/news/2012/Optimal-seating-chart.pdf
+# https://www.improbable.com/2012/02/12/finding-an-optimal-seating-chart-for-a-wedding
 #
 # Every year, millions of brides (not to mention their mothers, future
 # mothers-in-law, and occasionally grooms) struggle with one of the
@@ -1799,19 +2037,17 @@ all_tables.each do |t|
   end
 end
 
+pairs = all_guests.combination(2)
+
 colocated = {}
-(num_guests - 1).times do |g1|
-  (g1 + 1).upto(num_guests - 1) do |g2|
-    colocated[[g1, g2]] = model.new_bool_var("guest %i seats with guest %i" % [g1, g2])
-  end
+pairs.each do |g1, g2|
+  colocated[[g1, g2]] = model.new_bool_var("guest %i seats with guest %i" % [g1, g2])
 end
 
 same_table = {}
-(num_guests - 1).times do |g1|
-  (g1 + 1).upto(num_guests - 1) do |g2|
-    all_tables.each do |t|
-      same_table[[g1, g2, t]] = model.new_bool_var("guest %i seats with guest %i on table %i" % [g1, g2, t])
-    end
+pairs.each do |g1, g2|
+  all_tables.each do |t|
+    same_table[[g1, g2, t]] = model.new_bool_var("guest %i seats with guest %i on table %i" % [g1, g2, t])
   end
 end
 
@@ -1833,29 +2069,32 @@ all_tables.each do |t|
 end
 
 # Link colocated with seats
-(num_guests - 1).times do |g1|
-  (g1 + 1).upto(num_guests - 1) do |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]])
+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.
-all_tables.each do |t|
+all_guests.each do |g|
   model.add(
     model.sum(
-      (num_guests - 1).times.flat_map { |g1|
-        (g1 + 1).upto(num_guests - 1).select { |g2| c[g1][g2] > 0 }.flat_map { |g2|
-          all_tables.map { |t2| same_table[[g1, g2, t2]] }
-        }
-      }
+      (g + 1).upto(num_guests - 1).
+      select { |g2| c[g][g2] > 0 }.
+      product(all_tables).
+      map { |g2, t| same_table[[g, g2, t]] }
+    ) +
+    model.sum(
+      g.times.
+      select { |g1| c[g1][g] > 0 }.
+      product(all_tables).
+      map { |g1, t| same_table[[g1, g, t]] }
     ) >= min_known_neighbors
   )
 end

data/ext/or-tools/ext.cpp

@@ -661,6 +661,11 @@ void Init_ext()
       "_solution_integer_value",
       *[](Object self, CpSolverResponse& response, operations_research::sat::IntVar& x) {
         return SolutionIntegerValue(response, x);
+      })
+    .define_method(
+      "_solution_boolean_value",
+      *[](Object self, CpSolverResponse& response, operations_research::sat::BoolVar& x) {
+        return SolutionBooleanValue(response, x);
       });
 
   define_class_under<CpSolverResponse>(rb_mORTools, "CpSolverResponse")

data/ext/or-tools/vendor.rb

@@ -3,26 +3,26 @@ require "fileutils"
 require "net/http"
 require "tmpdir"
 
-version = "7.6.7691"
+version = "7.7.7810"
 
 if RbConfig::CONFIG["host_os"] =~ /darwin/i
-  filename = "or-tools_MacOsX-10.15.4_v#{version}.tar.gz"
-  checksum = "39e26ba27b4d3a1c194c1478e864cd016d62cf516cd9227a9f23e6143e131572"
+  filename = "or-tools_MacOsX-10.15.5_v#{version}.tar.gz"
+  checksum = "764f290f6d916bc366913a37d93e6f83bd7969ad33515ccc1ca390f544d65721"
 else
   os = %x[lsb_release -is].chomp rescue nil
   os_version = %x[lsb_release -rs].chomp rescue nil
   if os == "Ubuntu" && os_version == "18.04"
     filename = "or-tools_ubuntu-18.04_v#{version}.tar.gz"
-    checksum = "79ef61dfc63b98133ed637f02e837f714a95987424332e511a3a87edd5ce17dc"
+    checksum = "12bdac29144b077b3f9ba602f947e4b9b9ce63ed3df4e325cda1333827edbcf8"
   elsif os == "Ubuntu" && os_version == "16.04"
     filename = "or-tools_ubuntu-16.04_v#{version}.tar.gz"
-    checksum = "a25fc94c0f0d16abf1f6da2a054040c21ef3cbf618a831a15afe21bf14f2d1fb"
+    checksum = "cc696d342b97aa6cf7c62b6ae2cae95dfc665f2483d147c4117fdba434b13a53"
   elsif os == "Debian" && os_version == "10"
     filename = "or-tools_debian-10_v#{version}.tar.gz "
-    checksum = "158c44038aebc42b42b98e8f3733ba83bf230e8a0379803cc48aafbb2f7bdf5a"
+    checksum = "3dd0299e9ad8d12fe6d186bfd59e63080c8e9f3c6b0489af9900c389cf7e4224"
   elsif os == "CentOS" && os_version == "8"
     filename = "or-tools_centos-8_v#{version}.tar.gz"
-    checksum = "a2b800d4e498561e5b1fe95ee1e64c867be496038883f4f7b199499bf71a0eed"
+    checksum = "1f7d8bce56807c4283374e05024ffac8afd81ff99063217418d02d626cf03088"
   else
     # there is a binary download for Windows
     # however, it's compiled with Visual Studio rather than MinGW (which RubyInstaller uses)

data/lib/or-tools.rb

@@ -17,6 +17,12 @@ require "or_tools/sat_int_var"
 require "or_tools/solver"
 require "or_tools/version"
 
+# higher level interfaces
+require "or_tools/basic_scheduler"
+require "or_tools/seating"
+require "or_tools/sudoku"
+require "or_tools/tsp"
+
 module ORTools
   class Error < StandardError; end
 end

data/lib/or_tools/basic_scheduler.rb

@@ -0,0 +1,86 @@
+module ORTools
+  class BasicScheduler
+    attr_reader :assignments, :assigned_hours
+
+    # for time blocks (shifts and availability)
+    # could also use time range (starts_at..ends_at) or starts_at + duration
+    # keep current format for now for flexibility
+    def initialize(people:, shifts:)
+      @shifts = shifts
+
+      model = ORTools::CpModel.new
+
+      # create variables
+      # a person must be available for the entire shift to be considered for it
+      vars = []
+      shifts.each_with_index do |shift, i|
+        people.each_with_index do |person, j|
+          if person[:availability].any? { |a| a[:starts_at] <= shift[:starts_at] && a[:ends_at] >= shift[:ends_at] }
+            vars << {shift: i, person: j, var: model.new_bool_var("{shift: #{i}, person: #{j}}")}
+          end
+        end
+      end
+
+      vars_by_shift = vars.group_by { |v| v[:shift] }
+      vars_by_person = vars.group_by { |v| v[:person] }
+
+      # one person per shift
+      vars_by_shift.each do |j, vs|
+        model.add(model.sum(vs.map { |v| v[:var] }) <= 1)
+      end
+
+      # one shift per day per person
+      # in future, may also want to add option to ensure assigned shifts are N hours apart
+      vars_by_person.each do |j, vs|
+        vs.group_by { |v| shift_dates[v[:shift]] }.each do |_, vs2|
+          model.add(model.sum(vs2.map { |v| v[:var] }) <= 1)
+        end
+      end
+
+      # max hours per person
+      # use seconds since model needs integers
+      vars_by_person.each do |j, vs|
+        max_hours = people[j][:max_hours]
+        if max_hours
+          model.add(model.sum(vs.map { |v| v[:var] * shift_duration[v[:shift]] }) <= max_hours * 3600)
+        end
+      end
+
+      # maximize hours assigned
+      # could also include distance from max hours
+      model.maximize(model.sum(vars.map { |v| v[:var] * shift_duration[v[:shift]] }))
+
+      # solve
+      solver = ORTools::CpSolver.new
+      status = solver.solve(model)
+      raise Error, "No solution found" unless [:feasible, :optimal].include?(status)
+
+      # read solution
+      @assignments = []
+      vars.each do |v|
+        if solver.value(v[:var])
+          @assignments << {
+            person: v[:person],
+            shift: v[:shift]
+          }
+        end
+      end
+      # can calculate manually if objective changes
+      @assigned_hours = solver.objective_value / 3600.0
+    end
+
+    def total_hours
+      @total_hours ||= shift_duration.sum / 3600.0
+    end
+
+    private
+
+    def shift_duration
+      @shift_duration ||= @shifts.map { |s| (s[:ends_at] - s[:starts_at]).round }
+    end
+
+    def shift_dates
+      @shift_dates ||= @shifts.map { |s| s[:starts_at].to_date }
+    end
+  end
+end

data/lib/or_tools/cp_solver.rb

@@ -12,7 +12,11 @@ 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)

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.2.0"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: or-tools
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-23 00:00:00.000000000 Z
+date: 2020-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rice
@@ -95,19 +95,24 @@ files:
 - 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: