or-tools 0.1.3 → 0.1.4

data/README.md

@@ -66,32 +66,27 @@ Assignment
 Scheduling
 
 - [Employee Scheduling](#employee-scheduling)
+- [The Job Shop Problem](#the-job-shop-problem)
 
 Other Examples
 
 - [Sudoku](#sudoku)
+- [Wedding Seating Chart](#wedding-seating-chart)
 - [Set Partitioning](#set-partitioning)
 
 ### The Glop Linear Solver
 
 [Guide](https://developers.google.com/optimization/lp/glop)
 
-Declare the solver
-
 ```ruby
+# declare the solver
 solver = ORTools::Solver.new("LinearProgrammingExample", :glop)
-```
-
-Create the variables
 
-```ruby
+# create the variables
 x = solver.num_var(0, solver.infinity, "x")
 y = solver.num_var(0, solver.infinity, "y")
-```
 
-Define the constraints
-
-```ruby
+# define the constraints
 constraint0 = solver.constraint(-solver.infinity, 14)
 constraint0.set_coefficient(x, 1)
 constraint0.set_coefficient(y, 2)
@@ -103,26 +98,17 @@ constraint1.set_coefficient(y, -1)
 constraint2 = solver.constraint(-solver.infinity, 2)
 constraint2.set_coefficient(x, 1)
 constraint2.set_coefficient(y, -1)
-```
-
-Define the objective function
 
-```ruby
+# define the objective function
 objective = solver.objective
 objective.set_coefficient(x, 3)
 objective.set_coefficient(y, 4)
 objective.set_maximization
-```
-
-Invoke the solver
 
-```ruby
+# invoke the solver
 solver.solve
-```
 
-Display the solution
-
-```ruby
+# display the solution
 opt_solution = 3 * x.solution_value + 4 * y.solution_value
 puts "Number of variables = #{solver.num_variables}"
 puts "Number of constraints = #{solver.num_constraints}"
@@ -136,37 +122,24 @@ puts "Optimal objective value = #{opt_solution}"
 
 [Guide](https://developers.google.com/optimization/cp/cp_solver)
 
-Declare the model
-
 ```ruby
+# declare the model
 model = ORTools::CpModel.new
-```
 
-Create the variables
-
-```ruby
+# create the variables
 num_vals = 3
 x = model.new_int_var(0, num_vals - 1, "x")
 y = model.new_int_var(0, num_vals - 1, "y")
 z = model.new_int_var(0, num_vals - 1, "z")
-```
 
-Create the constraint
-
-```ruby
+# create the constraint
 model.add(x != y)
-```
-
-Call the solver
 
-```ruby
+# call the solver
 solver = ORTools::CpSolver.new
 status = solver.solve(model)
-```
 
-Display the first solution
-
-```ruby
+# display the first solution
 if status == :feasible
   puts "x = #{solver.value(x)}"
   puts "y = #{solver.value(y)}"
@@ -178,38 +151,25 @@ end
 
 [Guide](https://developers.google.com/optimization/cp/integer_opt_cp)
 
-Declare the model
-
 ```ruby
+# declare the model
 model = ORTools::CpModel.new
-```
 
-Create the variables
-
-```ruby
+# create the variables
 var_upper_bound = [50, 45, 37].max
 x = model.new_int_var(0, var_upper_bound, "x")
 y = model.new_int_var(0, var_upper_bound, "y")
 z = model.new_int_var(0, var_upper_bound, "z")
-```
-
-Define the constraints
 
-```ruby
+# define the constraints
 model.add(x*2 + y*7 + z*3 <= 50)
 model.add(x*3 - y*5 + z*7 <= 45)
 model.add(x*5 + y*2 - z*6 <= 37)
-```
-
-Define the objective function
 
-```ruby
+# define the objective function
 model.maximize(x*2 + y*2 + z*3)
-```
 
-Call the solver
-
-```ruby
+# call the solver
 solver = ORTools::CpSolver.new
 status = solver.solve(model)
 
@@ -226,9 +186,8 @@ end
 
 [Guide](https://developers.google.com/optimization/cp/cryptarithmetic)
 
-Define the variables
-
 ```ruby
+# define the variables
 model = ORTools::CpModel.new
 
 base = 10
@@ -245,20 +204,14 @@ r = model.new_int_var(0, base - 1, "R")
 e = model.new_int_var(0, base - 1, "E")
 
 letters = [c, p, i, s, f, u, n, t, r, e]
-```
 
-Define the constraints
-
-```ruby
+# define the constraints
 model.add_all_different(letters)
 
 model.add(c * base + p + i * base + s + f * base * base + u * base +
   n == t * base * base * base + r * base * base + u * base + e)
-```
 
-Define the solution printer
-
-```ruby
+# define the solution printer
 class VarArraySolutionPrinter < ORTools::CpSolverSolutionCallback
   attr_reader :solution_count
 
@@ -276,11 +229,8 @@ class VarArraySolutionPrinter < ORTools::CpSolverSolutionCallback
     puts
   end
 end
-```
-
-Invoke the solver
 
-```ruby
+# invoke the solver
 solver = ORTools::CpSolver.new
 solution_printer = VarArraySolutionPrinter.new(letters)
 status = solver.search_for_all_solutions(model, solution_printer)
@@ -298,22 +248,15 @@ puts "  - solutions found : %i" % solution_printer.solution_count
 
 [Guide](https://developers.google.com/optimization/cp/queens)
 
-Declare the model
-
 ```ruby
+# declare the model
 board_size = 8
 model = ORTools::CpModel.new
-```
-
-Create the variables
 
-```ruby
+# create the variables
 queens = board_size.times.map { |i| model.new_int_var(0, board_size - 1, "x%i" % i) }
-```
-
-Create the constraints
 
-```ruby
+# create the constraints
 board_size.times do |i|
   diag1 = []
   diag2 = []
@@ -328,11 +271,8 @@ board_size.times do |i|
   model.add_all_different(diag1)
   model.add_all_different(diag2)
 end
-```
 
-Create a solution printer
-
-```ruby
+# create a solution printer
 class SolutionPrinter < ORTools::CpSolverSolutionCallback
   attr_reader :solution_count
 
@@ -350,11 +290,8 @@ class SolutionPrinter < ORTools::CpSolverSolutionCallback
     puts
   end
 end
-```
-
-Call the solver and display the results
 
-```ruby
+# call the solver and display the results
 solver = ORTools::CpSolver.new
 solution_printer = SolutionPrinter.new(queens)
 status = solver.search_for_all_solutions(model, solution_printer)
@@ -366,25 +303,18 @@ puts "Solutions found : %i" % solution_printer.solution_count
 
 [Guide](https://developers.google.com/optimization/mip/integer_opt)
 
-Declare the MIP solver
-
 ```ruby
+# declare the MIP solver
 solver = ORTools::Solver.new("simple_mip_program", :cbc)
-```
-
-Define the variables
 
-```ruby
+# 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
-
-```ruby
+# define the constraints
 c0 = solver.constraint(-infinity, 17.5)
 c0.set_coefficient(x, 1)
 c0.set_coefficient(y, 7)
@@ -394,26 +324,17 @@ c1.set_coefficient(x, 1);
 c1.set_coefficient(y, 0);
 
 puts "Number of constraints = #{solver.num_constraints}"
-```
 
-Define the objective
-
-```ruby
+# define the objective
 objective = solver.objective
 objective.set_coefficient(x, 1)
 objective.set_coefficient(y, 10)
 objective.set_maximization
-```
-
-Call the solver
 
-```ruby
+# call the solver
 status = solver.solve
-```
 
-Display the solution
-
-```ruby
+# display the solution
 if status == :optimal
   puts "Solution:"
   puts "Objective value = #{solver.objective.value}"
@@ -428,9 +349,8 @@ end
 
 [Guide](https://developers.google.com/optimization/routing/tsp.html)
 
-Create the data
-
 ```ruby
+# create the data
 data = {}
 data[:distance_matrix] = [
   [0, 2451, 713, 1018, 1631, 1374, 2408, 213, 2571, 875, 1420, 2145, 1972],
@@ -449,11 +369,8 @@ data[:distance_matrix] = [
 ]
 data[:num_vehicles] = 1
 data[:depot] = 0
-```
-
-Create the distance callback
 
-```ruby
+# create the distance callback
 manager = ORTools::RoutingIndexManager.new(data[:distance_matrix].length, data[:num_vehicles], data[:depot])
 routing = ORTools::RoutingModel.new(manager)
 
@@ -465,17 +382,11 @@ end
 
 transit_callback_index = routing.register_transit_callback(distance_callback)
 routing.set_arc_cost_evaluator_of_all_vehicles(transit_callback_index)
-```
 
-Run the solver
-
-```ruby
+# run the solver
 assignment = routing.solve(first_solution_strategy: :path_cheaper_arc)
-```
-
-Print the solution
 
-```ruby
+# print the solution
 puts "Objective: #{assignment.objective_value} miles"
 index = routing.start(0)
 plan_output = String.new("Route for vehicle 0:\n")
@@ -494,9 +405,8 @@ puts plan_output
 
 [Guide](https://developers.google.com/optimization/routing/vrp)
 
-Create the data
-
 ```ruby
+# create the data
 data = {}
 data[:distance_matrix] = [
   [0, 548, 776, 696, 582, 274, 502, 194, 308, 194, 536, 502, 388, 354, 468, 776, 662],
@@ -519,11 +429,8 @@ data[:distance_matrix] = [
 ]
 data[:num_vehicles] = 4
 data[:depot] = 0
-```
 
-Define the distance callback
-
-```ruby
+# define the distance callback
 manager = ORTools::RoutingIndexManager.new(data[:distance_matrix].length, data[:num_vehicles], data[:depot])
 routing = ORTools::RoutingModel.new(manager)
 
@@ -535,26 +442,17 @@ end
 
 transit_callback_index = routing.register_transit_callback(distance_callback)
 routing.set_arc_cost_evaluator_of_all_vehicles(transit_callback_index)
-```
-
-Add a distance dimension
 
-```ruby
+# add a distance dimension
 dimension_name = "Distance"
 routing.add_dimension(transit_callback_index, 0, 3000, true, dimension_name)
 distance_dimension = routing.mutable_dimension(dimension_name)
 distance_dimension.global_span_cost_coefficient = 100
-```
 
-Run the solver
-
-```ruby
+# run the solver
 solution = routing.solve(first_solution_strategy: :path_cheapest_arc)
-```
-
-Print the solution
 
-```ruby
+# print the solution
 max_route_distance = 0
 data[:num_vehicles].times do |vehicle_id|
   index = routing.start(vehicle_id)
@@ -698,7 +596,6 @@ data[:num_vehicles] = 4
 data[:depot] = 0
 
 manager = ORTools::RoutingIndexManager.new(data[:distance_matrix].size, data[:num_vehicles], data[:depot])
-
 routing = ORTools::RoutingModel.new(manager)
 
 distance_callback = lambda do |from_index, to_index|
@@ -906,7 +803,6 @@ data[:depot_capacity] = 2
 data[:depot] = 0
 
 manager = ORTools::RoutingIndexManager.new(data[:time_matrix].size, data[:num_vehicles], data[:depot])
-
 routing = ORTools::RoutingModel.new(manager)
 
 time_callback = lambda do |from_index, to_index|
@@ -1014,7 +910,6 @@ data[:num_vehicles] = 4
 data[:depot] = 0
 
 manager = ORTools::RoutingIndexManager.new(data[:distance_matrix].size, data[:num_vehicles], data[:depot])
-
 routing = ORTools::RoutingModel.new(manager)
 
 distance_callback = lambda do |from_index, to_index|
@@ -1103,9 +998,8 @@ routing.solve(
 
 [Guide](https://developers.google.com/optimization/bin/knapsack)
 
-Create the data
-
 ```ruby
+# create the data
 values = [
   360, 83, 59, 130, 431, 67, 230, 52, 93, 125, 670, 892, 600, 38, 48, 147,
   78, 256, 63, 17, 120, 164, 432, 35, 92, 110, 22, 42, 50, 323, 514, 28,
@@ -1118,17 +1012,11 @@ weights = [[
   3, 86, 66, 31, 65, 0, 79, 20, 65, 52, 13
 ]]
 capacities = [850]
-```
-
-Declare the solver
 
-```ruby
+# declare the solver
 solver = ORTools::KnapsackSolver.new(:branch_and_bound, "KnapsackExample")
-```
 
-Call the solver
-
-```ruby
+# call the solver
 solver.init(values, weights, capacities)
 computed_value = solver.solve
 
@@ -1152,9 +1040,8 @@ puts "Packed weights: #{packed_weights}"
 
 [Guide](https://developers.google.com/optimization/bin/multiple_knapsack)
 
-Create the data
-
 ```ruby
+# create the data
 data = {}
 weights = [48, 30, 42, 36, 36, 48, 42, 42, 36, 24, 30, 30, 42, 36, 36]
 values = [10, 30, 25, 50, 35, 30, 15, 40, 30, 35, 45, 10, 20, 30, 25]
@@ -1165,28 +1052,21 @@ data[:num_items] = weights.length
 num_bins = 5
 data[:bins] = (0...num_bins).to_a
 data[:bin_capacities] = [100, 100, 100, 100, 100]
-```
-
-Declare the solver
 
-```ruby
+# declare the solver
 solver = ORTools::Solver.new("simple_mip_program", :cbc)
-```
 
-Create the variables
-
-```ruby
+# create the variables
+# x[i, j] = 1 if item i is packed in bin j
 x = {}
 data[:items].each do |i|
   data[:bins].each do |j|
     x[[i, j]] = solver.int_var(0, 1, "x_%i_%i" % [i, j])
   end
 end
-```
-
-Define the constraints
 
-```ruby
+# define the constraints
+# each item can be in at most one bin
 data[:items].each do |i|
   sum = ORTools::LinearExpr.new
   data[:bins].each do |j|
@@ -1195,6 +1075,7 @@ data[:items].each do |i|
   solver.add(sum <= 1.0)
 end
 
+# the amount packed in each bin cannot exceed its capacity
 data[:bins].each do |j|
   weight = ORTools::LinearExpr.new
   data[:items].each do |i|
@@ -1202,11 +1083,8 @@ data[:bins].each do |j|
   end
   solver.add(weight <= data[:bin_capacities][j])
 end
-```
-
-Define the objective
 
-```ruby
+# define the objective
 objective = solver.objective
 
 data[:items].each do |i|
@@ -1215,11 +1093,8 @@ data[:items].each do |i|
   end
 end
 objective.set_maximization
-```
 
-Call the solver and print the solution
-
-```ruby
+# call the solver and print the solution
 status = solver.solve
 
 if status == :optimal
@@ -1251,26 +1126,20 @@ end
 
 [Guide](https://developers.google.com/optimization/bin/bin_packing)
 
-Create the data
-
 ```ruby
+# create the data
 data = {}
 weights = [48, 30, 19, 36, 36, 27, 42, 42, 36, 24, 30]
 data[:weights] = weights
 data[:items] = (0...weights.length).to_a
 data[:bins] = data[:items]
 data[:bin_capacity] = 100
-```
 
-Declare the solver
-
-```ruby
+# create the mip solver with the CBC backend
 solver = ORTools::Solver.new("simple_mip_program", :cbc)
-```
-
-Create the variables
 
-```ruby
+# variables
+# x[i, j] = 1 if item i is packed in bin j
 x = {}
 data[:items].each do |i|
   data[:bins].each do |j|
@@ -1278,34 +1147,28 @@ data[:items].each do |i|
   end
 end
 
+# y[j] = 1 if bin j is used
 y = {}
 data[:bins].each do |j|
   y[j] = solver.int_var(0, 1, "y[%i]" % j)
 end
-```
 
-Define the constraints
-
-```ruby
+# constraints
+# each item must be in exactly one bin
 data[:items].each do |i|
   solver.add(solver.sum(data[:bins].map { |j| x[[i, j]] }) == 1)
 end
 
+# the amount packed in each bin cannot exceed its capacity
 data[:bins].each do |j|
   sum = solver.sum(data[:items].map { |i| x[[i, j]] * data[:weights][i] })
   solver.add(sum <= y[j] * data[:bin_capacity])
 end
-```
-
-Define the objective
 
-```ruby
+# objective: minimize the number of bins used
 solver.minimize(solver.sum(data[:bins].map { |j| y[j] }))
-```
-
-Call the solver and print the solution
 
-```ruby
+# call the solver and print the solution
 if status == :optimal
   num_bins = 0
   data[:bins].each do |j|
@@ -1339,27 +1202,20 @@ end
 
 [Guide](https://developers.google.com/optimization/flow/maxflow)
 
-Define the data
-
 ```ruby
+# define the data
 start_nodes = [0, 0, 0, 1, 1, 2, 2, 3, 3]
 end_nodes = [1, 2, 3, 2, 4, 3, 4, 2, 4]
 capacities = [20, 30, 10, 40, 30, 10, 20, 5, 20]
-```
-
-Declare the solver and add the arcs
 
-```ruby
+# declare the solver and add the arcs
 max_flow = ORTools::SimpleMaxFlow.new
 
 start_nodes.length.times do |i|
   max_flow.add_arc_with_capacity(start_nodes[i], end_nodes[i], capacities[i])
 end
-```
-
-Invoke the solver and display the results
 
-```ruby
+# invoke the solver and display the results
 if max_flow.solve(0, 4) == :optimal
   puts "Max flow: #{max_flow.optimal_flow}"
   puts
@@ -1383,19 +1239,15 @@ end
 
 [Guide](https://developers.google.com/optimization/flow/mincostflow)
 
-Define the data
-
 ```ruby
+# define the data
 start_nodes = [ 0, 0,  1, 1,  1,  2, 2,  3, 4]
 end_nodes   = [ 1, 2,  2, 3,  4,  3, 4,  4, 2]
 capacities  = [15, 8, 20, 4, 10, 15, 4, 20, 5]
 unit_costs  = [ 4, 4,  2, 2,  6,  1, 3,  2, 3]
 supplies = [20, 0, 0, -5, -15]
-```
-
-Declare the solver and add the arcs
 
-```ruby
+# declare the solver and add the arcs
 min_cost_flow = ORTools::SimpleMinCostFlow.new
 
 start_nodes.length.times do |i|
@@ -1407,11 +1259,8 @@ end
 supplies.length.times do |i|
   min_cost_flow.set_node_supply(i, supplies[i])
 end
-```
 
-Invoke the solver and display the results
-
-```ruby
+# invoke the solver and display the results
 if min_cost_flow.solve == :optimal
   puts "Minimum cost #{min_cost_flow.optimal_cost}"
   puts
@@ -1431,13 +1280,12 @@ else
 end
 ```
 
-## Assignment
+### Assignment
 
 [Guide](https://developers.google.com/optimization/assignment/simple_assignment)
 
-Create the data
-
 ```ruby
+# create the data
 cost = [[ 90,  76, 75,  70],
         [ 35,  85, 55,  65],
         [125,  95, 90, 105],
@@ -1445,17 +1293,11 @@ cost = [[ 90,  76, 75,  70],
 
 rows = cost.length
 cols = cost[0].length
-```
-
-Create the solver
 
-```ruby
+# create the solver
 assignment = ORTools::LinearSumAssignment.new
-```
 
-Add the costs to the solver
-
-```ruby
+# add the costs to the solver
 rows.times do |worker|
   cols.times do |task|
     if cost[worker][task]
@@ -1463,11 +1305,8 @@ rows.times do |worker|
     end
   end
 end
-```
-
-Invoke the solver
 
-```ruby
+# invoke the solver
 solve_status = assignment.solve
 if solve_status == :optimal
   puts "Total cost = #{assignment.optimal_cost}"
@@ -1486,19 +1325,15 @@ elsif solve_status == :possible_overflow
 end
 ```
 
-## Assignment as a Min Cost Problem
+### Assignment as a Min Cost Problem
 
 [Guide](https://developers.google.com/optimization/assignment/assignment_min_cost_flow)
 
-Create the solver
-
 ```ruby
+# create the solver
 min_cost_flow = ORTools::SimpleMinCostFlow.new
-```
-
-Create the data
 
-```ruby
+# create the data
 start_nodes = [0, 0, 0, 0] + [1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4] + [5, 6, 7, 8]
 end_nodes = [1, 2, 3, 4] + [5, 6, 7, 8, 5, 6, 7, 8, 5, 6, 7, 8, 5, 6, 7, 8] + [9, 9, 9, 9]
 capacities = [1, 1, 1, 1] + [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] + [1, 1, 1, 1]
@@ -1507,11 +1342,8 @@ supplies = [4, 0, 0, 0, 0, 0, 0, 0, 0, -4]
 source = 0
 sink = 9
 tasks = 4
-```
 
-Create the graph and constraints
-
-```ruby
+# create the graph and constraints
 start_nodes.length.times do |i|
   min_cost_flow.add_arc_with_capacity_and_unit_cost(
     start_nodes[i], end_nodes[i], capacities[i], costs[i]
@@ -1521,11 +1353,8 @@ end
 supplies.length.times do |i|
   min_cost_flow.set_node_supply(i, supplies[i])
 end
-```
 
-Invoke the solver
-
-```ruby
+# invoke the solver
 if min_cost_flow.solve == :optimal
   puts "Total cost = #{min_cost_flow.optimal_cost}"
   puts
@@ -1545,19 +1374,15 @@ else
 end
 ```
 
-## Assignment as a MIP Problem
+### Assignment as a MIP Problem
 
 [Guide](https://developers.google.com/optimization/assignment/assignment_mip)
 
-Create the solver
-
 ```ruby
+# create the solver
 solver = ORTools::Solver.new("SolveAssignmentProblemMIP", :cbc)
-```
 
-Create the data
-
-```ruby
+# create the data
 cost = [[90, 76, 75, 70],
         [35, 85, 55, 65],
         [125, 95, 90, 105],
@@ -1568,11 +1393,8 @@ cost = [[90, 76, 75, 70],
 team1 = [0, 2, 4]
 team2 = [1, 3, 5]
 team_max = 2
-```
-
-Create the variables
 
-```ruby
+# create the variables
 num_workers = cost.length
 num_tasks = cost[1].length
 x = {}
@@ -1582,19 +1404,13 @@ num_workers.times do |i|
     x[[i, j]] = solver.bool_var("x[#{i},#{j}]")
   end
 end
-```
-
-Create the objective function
 
-```ruby
+# 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
-
-```ruby
+# create the constraints
 num_workers.times do |i|
   solver.add(solver.sum(num_tasks.times.map { |j| x[[i, j]] }) <= 1)
 end
@@ -1605,11 +1421,8 @@ 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
 
-```ruby
+# invoke the solver
 sol = solver.solve
 
 puts "Total cost = #{solver.objective.value}"
@@ -1630,24 +1443,20 @@ puts
 puts "Time = #{solver.wall_time} milliseconds"
 ```
 
-## Employee Scheduling
+### Employee Scheduling
 
 [Guide](https://developers.google.com/optimization/scheduling/employee_scheduling)
 
-Define the data
-
 ```ruby
+# define the data
 num_nurses = 4
 num_shifts = 3
 num_days = 3
 all_nurses = num_nurses.times.to_a
 all_shifts = num_shifts.times.to_a
 all_days = num_days.times.to_a
-```
 
-Create the variables
-
-```ruby
+# create the variables
 model = ORTools::CpModel.new
 
 shifts = {}
@@ -1658,11 +1467,8 @@ all_nurses.each do |n|
     end
   end
 end
-```
-
-Assign nurses to shifts
 
-```ruby
+# assign nurses to shifts
 all_days.each do |d|
   all_shifts.each do |s|
     model.add(model.sum(all_nurses.map { |n| shifts[[n, d, s]] }) == 1)
@@ -1674,11 +1480,8 @@ all_nurses.each do |n|
     model.add(model.sum(all_shifts.map { |s| shifts[[n, d, s]] }) <= 1)
   end
 end
-```
 
-Assign shifts evenly
-
-```ruby
+# assign shifts evenly
 min_shifts_per_nurse = (num_shifts * num_days) / num_nurses
 max_shifts_per_nurse = min_shifts_per_nurse + 1
 all_nurses.each do |n|
@@ -1686,11 +1489,8 @@ all_nurses.each do |n|
   model.add(num_shifts_worked >= min_shifts_per_nurse)
   model.add(num_shifts_worked <= max_shifts_per_nurse)
 end
-```
-
-Create a printer
 
-```ruby
+# create a printer
 class NursesPartialSolutionPrinter < ORTools::CpSolverSolutionCallback
   attr_reader :solution_count
 
@@ -1727,11 +1527,8 @@ class NursesPartialSolutionPrinter < ORTools::CpSolverSolutionCallback
     @solution_count += 1
   end
 end
-```
 
-Call the solver and display the results
-
-```ruby
+# call the solver and display the results
 solver = ORTools::CpSolver.new
 a_few_solutions = 5.times.to_a
 solution_printer = NursesPartialSolutionPrinter.new(
@@ -1747,7 +1544,110 @@ puts "  - wall time       : %f s" % solver.wall_time
 puts "  - solutions found : %i" % solution_printer.solution_count
 ```
 
-## Sudoku
+### The Job Shop Problem
+
+[Guide](https://developers.google.com/optimization/scheduling/job_shop)
+
+```ruby
+# create the model
+model = ORTools::CpModel.new
+
+jobs_data = [
+  [[0, 3], [1, 2], [2, 2]],
+  [[0, 2], [2, 1], [1, 4]],
+  [[1, 4], [2, 3]]
+]
+
+machines_count = 1 + jobs_data.flat_map { |job| job.map { |task| task[0] }  }.max
+all_machines = machines_count.times.to_a
+
+# computes horizon dynamically as the sum of all durations
+horizon = jobs_data.flat_map { |job| job.map { |task| task[1] }  }.sum
+
+# creates job intervals and add to the corresponding machine lists
+all_tasks = {}
+machine_to_intervals = Hash.new { |hash, key| hash[key] = [] }
+
+jobs_data.each_with_index do |job, job_id|
+  job.each_with_index do |task, task_id|
+    machine = task[0]
+    duration = task[1]
+    suffix = "_%i_%i" % [job_id, task_id]
+    start_var = model.new_int_var(0, horizon, "start" + suffix)
+    duration_var = model.new_int_var(duration, duration, "duration" + suffix)
+    end_var = model.new_int_var(0, horizon, "end" + suffix)
+    interval_var = model.new_interval_var(start_var, duration_var, end_var, "interval" + suffix)
+    all_tasks[[job_id, task_id]] = {start: start_var, end: end_var, interval: interval_var}
+    machine_to_intervals[machine] << interval_var
+  end
+end
+
+# create and add disjunctive constraints
+all_machines.each do |machine|
+  model.add_no_overlap(machine_to_intervals[machine])
+end
+
+# precedences inside a job
+jobs_data.each_with_index do |job, job_id|
+  (job.size - 1).times do |task_id|
+    model.add(all_tasks[[job_id, task_id + 1]][:start] >= all_tasks[[job_id, task_id]][:end])
+  end
+end
+
+# makespan objective
+obj_var = model.new_int_var(0, horizon, "makespan")
+model.add_max_equality(obj_var, jobs_data.map.with_index { |job, job_id| all_tasks[[job_id, job.size - 1]][:end] })
+model.minimize(obj_var)
+
+# solve model
+solver = ORTools::CpSolver.new
+status = solver.solve(model)
+
+# create one list of assigned tasks per machine
+assigned_jobs = Hash.new { |hash, key| hash[key] = [] }
+jobs_data.each_with_index do |job, job_id|
+  job.each_with_index do |task, task_id|
+    machine = task[0]
+    assigned_jobs[machine] << {
+      start: solver.value(all_tasks[[job_id, task_id]][:start]),
+      job: job_id,
+      index: task_id,
+      duration: task[1]
+    }
+  end
+end
+
+# create per machine output lines
+output = String.new("")
+all_machines.each do |machine|
+  # sort by starting time
+  assigned_jobs[machine].sort_by! { |v| v[:start] }
+  sol_line_tasks = "Machine #{machine}: "
+  sol_line = "           "
+
+  assigned_jobs[machine].each do |assigned_task|
+    name = "job_%i_%i" % [assigned_task[:job], assigned_task[:index]]
+    # add spaces to output to align columns
+    sol_line_tasks += "%-10s" % name
+    start = assigned_task[:start]
+    duration = assigned_task[:duration]
+    sol_tmp = "[%i,%i]" % [start, start + duration]
+    # add spaces to output to align columns
+    sol_line += "%-10s" % sol_tmp
+  end
+
+  sol_line += "\n"
+  sol_line_tasks += "\n"
+  output += sol_line_tasks
+  output += sol_line
+end
+
+# finally print the solution found
+puts "Optimal Schedule Length: %i" % solver.objective_value
+puts output
+```
+
+### Sudoku
 
 [Example](https://github.com/google/or-tools/blob/stable/examples/python/sudoku_sat.py)
 
@@ -1821,7 +1721,165 @@ if status == :feasible
 end
 ```
 
-## Set Partitioning
+### Wedding Seating Chart
+
+[Example](https://github.com/google/or-tools/blob/stable/examples/python/wedding_optimal_chart_sat.py)
+
+```ruby
+# 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
+#
+# Every year, millions of brides (not to mention their mothers, future
+# mothers-in-law, and occasionally grooms) struggle with one of the
+# most daunting tasks during the wedding-planning process: the
+# seating chart. The guest responses are in, banquet hall is booked,
+# menu choices have been made. You think the hard parts are over,
+# but you have yet to embark upon the biggest headache of them all.
+# In order to make this process easier, we present a mathematical
+# formulation that models the seating chart problem. This model can
+# be solved to find the optimal arrangement of guests at tables.
+# At the very least, it can provide a starting point and hopefully
+# minimize stress and arguments.
+#
+# Adapted from
+# https://github.com/google/or-tools/blob/stable/examples/python/wedding_optimal_chart_sat.py
+
+# Easy problem (from the paper)
+# num_tables = 2
+# table_capacity = 10
+# min_known_neighbors = 1
+
+# Slightly harder problem (also from the paper)
+num_tables = 5
+table_capacity = 4
+min_known_neighbors = 1
+
+# Connection matrix: who knows who, and how strong
+# is the relation
+c = [
+  [1, 50, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0],
+  [50, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0],
+  [1, 1, 1, 50, 1, 1, 1, 1, 10, 0, 0, 0, 0, 0, 0, 0, 0],
+  [1, 1, 50, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0],
+  [1, 1, 1, 1, 1, 50, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0],
+  [1, 1, 1, 1, 50, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0],
+  [1, 1, 1, 1, 1, 1, 1, 50, 1, 0, 0, 0, 0, 0, 0, 0, 0],
+  [1, 1, 1, 1, 1, 1, 50, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0],
+  [1, 1, 10, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0],
+  [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 50, 1, 1, 1, 1, 1, 1],
+  [0, 0, 0, 0, 0, 0, 0, 0, 0, 50, 1, 1, 1, 1, 1, 1, 1],
+  [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1],
+  [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1],
+  [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1],
+  [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1],
+  [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1],
+  [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1]
+]
+
+# Names of the guests. B: Bride side, G: Groom side
+names = [
+  "Deb (B)", "John (B)", "Martha (B)", "Travis (B)", "Allan (B)",
+  "Lois (B)", "Jayne (B)", "Brad (B)", "Abby (B)", "Mary Helen (G)",
+  "Lee (G)", "Annika (G)", "Carl (G)", "Colin (G)", "Shirley (G)",
+  "DeAnn (G)", "Lori (G)"
+]
+
+num_guests = c.size
+
+all_tables = num_tables.times.to_a
+all_guests = num_guests.times.to_a
+
+# create the cp model
+model = ORTools::CpModel.new
+
+# decision variables
+seats = {}
+all_tables.each do |t|
+  all_guests.each do |g|
+    seats[[t, g]] = model.new_bool_var("guest %i seats on table %i" % [g, t])
+  end
+end
+
+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
+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
+  end
+end
+
+# Objective
+model.maximize(model.sum((num_guests - 1).times.flat_map { |g1| (g1 + 1).upto(num_guests - 1).select { |g2| c[g1][g2] > 0 }.map { |g2| colocated[[g1, g2]] * c[g1][g2] } }))
+
+#
+# Constraints
+#
+
+# Everybody seats at one table.
+all_guests.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(all_guests.map { |g| seats[[t, g]] }) <= table_capacity)
+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]])
+  end
+end
+
+# Min known neighbors rule.
+all_tables.each do |t|
+  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]] }
+        }
+      }
+    ) >= min_known_neighbors
+  )
+end
+
+# Symmetry breaking. First guest seats on the first table.
+model.add(seats[[0, 0]] == 1)
+
+# Solve model
+solver = ORTools::CpSolver.new
+solution_printer = WeddingChartPrinter.new(seats, names, num_tables, num_guests)
+solver.solve_with_solution_callback(model, solution_printer)
+
+puts "Statistics"
+puts "  - conflicts    : %i" % solver.num_conflicts
+puts "  - branches     : %i" % solver.num_branches
+puts "  - wall time    : %f s" % solver.wall_time
+puts "  - num solutions: %i" % solution_printer.num_solutions
+```
+
+### Set Partitioning
 
 [Example](https://pythonhosted.org/PuLP/CaseStudies/a_set_partitioning_problem.html)