or-tools 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3d0010ac9fa141621f67cee4eb00ba077a5bafcec58c65202d477c1576ba797e
-  data.tar.gz: '0328a9b9f0fa296df875e0756b40dc16fdbf756725d5ecc4e3bc23c600245974'
+  metadata.gz: 9681fd5e91b33fa5eca9ad0611011a93e6cd7f1edf12fed4e9956d914725738c
+  data.tar.gz: a44de2a7f7c86cd6b341abc72e2cf11dab73b3ecd9599b8b00664333af837739
 SHA512:
-  metadata.gz: dd66a479521af3f036ed14f639f957cd6b608efed729a4e7ed1eb5fde749fd779ec471750b93ab5d48e0162116e9865c0763355fd72b610a0b74cf6747dad220
-  data.tar.gz: 41af8a12b7aa110baae1f62029c4bde6e291ea1b870f9435ba3463a1a9e52d41dc069ef049671a95802d3942e29402f7096709c6a8fd659382a372923e03002a
+  metadata.gz: 68bd5337214d4ef54a6d5fd6750beb493372c9735ab6a1dc40d22cac2e08804d1fcb241f0dfb50f02980d202837405edd9c3ffcaa723a34e291a0a6d194c38a0
+  data.tar.gz: 0e43f33feaa383093c2b46e620bc2976e27a21441e86be52fd1310c2f2bc13aa0385dd96f9e46b88215384f843c1e94c85c6471fd501ab8ab26a7ad15d4fa252

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 0.1.3 (2020-03-24)
+
+- Added support for more routing problems
+- Added `add_all_different` to `CpModel`
+
 ## 0.1.2 (2020-02-18)
 
 - Added support for scheduling

data/README.md

@@ -28,6 +28,8 @@ Constraint Optimization
 
 - [CP-SAT Solver](#cp-sat-solver)
 - [Solving an Optimization Problem](#solving-an-optimization-problem)
+- [Cryptarithmetic](#cryptarithmetic)
+- [The N-queens Problem](#the-n-queens-problem)
 
 Integer Optimization
 
@@ -37,6 +39,11 @@ Routing
 
 - [Traveling Salesperson Problem (TSP)](#traveling-salesperson-problem-tsp)
 - [Vehicle Routing Problem (VRP)](#vehicle-routing-problem-vrp)
+- [Capacity Constraints](#capacity-constraints)
+- [Pickups and Deliveries](#pickups-and-deliveries)
+- [Time Window Constraints](#time-window-constraints)
+- [Resource Constraints](#resource-constraints)
+- [Penalties and Dropping Visits](#penalties-and-dropping-visits)
 - [Routing Options](#routing-options)
 
 Bin Packing
@@ -60,6 +67,11 @@ Scheduling
 
 - [Employee Scheduling](#employee-scheduling)
 
+Other Examples
+
+- [Sudoku](#sudoku)
+- [Set Partitioning](#set-partitioning)
+
 ### The Glop Linear Solver
 
 [Guide](https://developers.google.com/optimization/lp/glop)
@@ -210,6 +222,146 @@ if status == :optimal
 end
 ```
 
+### Cryptarithmetic
+
+[Guide](https://developers.google.com/optimization/cp/cryptarithmetic)
+
+Define the variables
+
+```ruby
+model = ORTools::CpModel.new
+
+base = 10
+
+c = model.new_int_var(1, base - 1, "C")
+p = model.new_int_var(0, base - 1, "P")
+i = model.new_int_var(1, base - 1, "I")
+s = model.new_int_var(0, base - 1, "S")
+f = model.new_int_var(1, base - 1, "F")
+u = model.new_int_var(0, base - 1, "U")
+n = model.new_int_var(0, base - 1, "N")
+t = model.new_int_var(1, base - 1, "T")
+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
+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
+class VarArraySolutionPrinter < ORTools::CpSolverSolutionCallback
+  attr_reader :solution_count
+
+  def initialize(variables)
+    super()
+    @variables = variables
+    @solution_count = 0
+  end
+
+  def on_solution_callback
+    @solution_count += 1
+    @variables.each do |v|
+      print "%s=%i " % [v.name, value(v)]
+    end
+    puts
+  end
+end
+```
+
+Invoke the solver
+
+```ruby
+solver = ORTools::CpSolver.new
+solution_printer = VarArraySolutionPrinter.new(letters)
+status = solver.search_for_all_solutions(model, solution_printer)
+
+puts
+puts "Statistics"
+puts "  - status          : %s" % status
+puts "  - conflicts       : %i" % solver.num_conflicts
+puts "  - branches        : %i" % solver.num_branches
+puts "  - wall time       : %f s" % solver.wall_time
+puts "  - solutions found : %i" % solution_printer.solution_count
+```
+
+### The N-queens Problem
+
+[Guide](https://developers.google.com/optimization/cp/queens)
+
+Declare the model
+
+```ruby
+board_size = 8
+model = ORTools::CpModel.new
+```
+
+Create the variables
+
+```ruby
+queens = board_size.times.map { |i| model.new_int_var(0, board_size - 1, "x%i" % i) }
+```
+
+Create the constraints
+
+```ruby
+board_size.times do |i|
+  diag1 = []
+  diag2 = []
+  board_size.times do |j|
+    q1 = model.new_int_var(0, 2 * board_size, "diag1_%i" % i)
+    diag1 << q1
+    model.add(q1 == queens[j] + j)
+    q2 = model.new_int_var(-board_size, board_size, "diag2_%i" % i)
+    diag2 << q2
+    model.add(q2 == queens[j] - j)
+  end
+  model.add_all_different(diag1)
+  model.add_all_different(diag2)
+end
+```
+
+Create a solution printer
+
+```ruby
+class SolutionPrinter < ORTools::CpSolverSolutionCallback
+  attr_reader :solution_count
+
+  def initialize(variables)
+    super()
+    @variables = variables
+    @solution_count = 0
+  end
+
+  def on_solution_callback
+    @solution_count += 1
+    @variables.each do |v|
+      print "%s = %i " % [v.name, value(v)]
+    end
+    puts
+  end
+end
+```
+
+Call the solver and display the results
+
+```ruby
+solver = ORTools::CpSolver.new
+solution_printer = SolutionPrinter.new(queens)
+status = solver.search_for_all_solutions(model, solution_printer)
+puts
+puts "Solutions found : %i" % solution_printer.solution_count
+```
+
 ### Mixed-Integer Programming
 
 [Guide](https://developers.google.com/optimization/mip/integer_opt)
@@ -422,6 +574,516 @@ end
 puts "Maximum of the route distances: #{max_route_distance}m"
 ```
 
+### Capacity Constraints
+
+[Guide](https://developers.google.com/optimization/routing/cvrp)
+
+```ruby
+data = {}
+data[:distance_matrix] = [
+  [0, 548, 776, 696, 582, 274, 502, 194, 308, 194, 536, 502, 388, 354, 468, 776, 662],
+  [548, 0, 684, 308, 194, 502, 730, 354, 696, 742, 1084, 594, 480, 674, 1016, 868, 1210],
+  [776, 684, 0, 992, 878, 502, 274, 810, 468, 742, 400, 1278, 1164, 1130, 788, 1552, 754],
+  [696, 308, 992, 0, 114, 650, 878, 502, 844, 890, 1232, 514, 628, 822, 1164, 560, 1358],
+  [582, 194, 878, 114, 0, 536, 764, 388, 730, 776, 1118, 400, 514, 708, 1050, 674, 1244],
+  [274, 502, 502, 650, 536, 0, 228, 308, 194, 240, 582, 776, 662, 628, 514, 1050, 708],
+  [502, 730, 274, 878, 764, 228, 0, 536, 194, 468, 354, 1004, 890, 856, 514, 1278, 480],
+  [194, 354, 810, 502, 388, 308, 536, 0, 342, 388, 730, 468, 354, 320, 662, 742, 856],
+  [308, 696, 468, 844, 730, 194, 194, 342, 0, 274, 388, 810, 696, 662, 320, 1084, 514],
+  [194, 742, 742, 890, 776, 240, 468, 388, 274, 0, 342, 536, 422, 388, 274, 810, 468],
+  [536, 1084, 400, 1232, 1118, 582, 354, 730, 388, 342, 0, 878, 764, 730, 388, 1152, 354],
+  [502, 594, 1278, 514, 400, 776, 1004, 468, 810, 536, 878, 0, 114, 308, 650, 274, 844],
+  [388, 480, 1164, 628, 514, 662, 890, 354, 696, 422, 764, 114, 0, 194, 536, 388, 730],
+  [354, 674, 1130, 822, 708, 628, 856, 320, 662, 388, 730, 308, 194, 0, 342, 422, 536],
+  [468, 1016, 788, 1164, 1050, 514, 514, 662, 320, 274, 388, 650, 536, 342, 0, 764, 194],
+  [776, 868, 1552, 560, 674, 1050, 1278, 742, 1084, 810, 1152, 274, 388, 422, 764, 0, 798],
+  [662, 1210, 754, 1358, 1244, 708, 480, 856, 514, 468, 354, 844, 730, 536, 194, 798, 0]
+]
+data[:demands] = [0, 1, 1, 2, 4, 2, 4, 8, 8, 1, 2, 1, 2, 4, 4, 8, 8]
+data[:vehicle_capacities] = [15, 15, 15, 15]
+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|
+  from_node = manager.index_to_node(from_index)
+  to_node = manager.index_to_node(to_index)
+  data[: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)
+
+demand_callback = lambda do |from_index|
+  from_node = manager.index_to_node(from_index)
+  data[:demands][from_node]
+end
+
+demand_callback_index = routing.register_unary_transit_callback(demand_callback)
+routing.add_dimension_with_vehicle_capacity(
+  demand_callback_index,
+  0,  # null capacity slack
+  data[:vehicle_capacities],  # vehicle maximum capacities
+  true,  # start cumul to zero
+  "Capacity"
+)
+
+solution = routing.solve(first_solution_strategy: :path_cheapest_arc)
+
+total_distance = 0
+total_load = 0
+data[:num_vehicles].times do |vehicle_id|
+  index = routing.start(vehicle_id)
+  plan_output = String.new("Route for vehicle #{vehicle_id}:\n")
+  route_distance = 0
+  route_load = 0
+  while !routing.end?(index)
+    node_index = manager.index_to_node(index)
+    route_load += data[:demands][node_index]
+    plan_output += " #{node_index} Load(#{route_load}) -> "
+    previous_index = index
+    index = solution.value(routing.next_var(index))
+    route_distance += routing.arc_cost_for_vehicle(previous_index, index, vehicle_id)
+  end
+  plan_output += " #{manager.index_to_node(index)} Load(#{route_load})\n"
+  plan_output += "Distance of the route: #{route_distance}m\n"
+  plan_output += "Load of the route: #{route_load}\n\n"
+  puts plan_output
+  total_distance += route_distance
+  total_load += route_load
+end
+puts "Total distance of all routes: #{total_distance}m"
+puts "Total load of all routes: #{total_load}"
+```
+
+### Pickups and Deliveries
+
+[Guide](https://developers.google.com/optimization/routing/pickup_delivery)
+
+```ruby
+data = {}
+data[:distance_matrix] = [
+  [0, 548, 776, 696, 582, 274, 502, 194, 308, 194, 536, 502, 388, 354, 468, 776, 662],
+  [548, 0, 684, 308, 194, 502, 730, 354, 696, 742, 1084, 594, 480, 674, 1016, 868, 1210],
+  [776, 684, 0, 992, 878, 502, 274, 810, 468, 742, 400, 1278, 1164, 1130, 788, 1552, 754],
+  [696, 308, 992, 0, 114, 650, 878, 502, 844, 890, 1232, 514, 628, 822, 1164, 560, 1358],
+  [582, 194, 878, 114, 0, 536, 764, 388, 730, 776, 1118, 400, 514, 708, 1050, 674, 1244],
+  [274, 502, 502, 650, 536, 0, 228, 308, 194, 240, 582, 776, 662, 628, 514, 1050, 708],
+  [502, 730, 274, 878, 764, 228, 0, 536, 194, 468, 354, 1004, 890, 856, 514, 1278, 480],
+  [194, 354, 810, 502, 388, 308, 536, 0, 342, 388, 730, 468, 354, 320, 662, 742, 856],
+  [308, 696, 468, 844, 730, 194, 194, 342, 0, 274, 388, 810, 696, 662, 320, 1084, 514],
+  [194, 742, 742, 890, 776, 240, 468, 388, 274, 0, 342, 536, 422, 388, 274, 810, 468],
+  [536, 1084, 400, 1232, 1118, 582, 354, 730, 388, 342, 0, 878, 764, 730, 388, 1152, 354],
+  [502, 594, 1278, 514, 400, 776, 1004, 468, 810, 536, 878, 0, 114, 308, 650, 274, 844],
+  [388, 480, 1164, 628, 514, 662, 890, 354, 696, 422, 764, 114, 0, 194, 536, 388, 730],
+  [354, 674, 1130, 822, 708, 628, 856, 320, 662, 388, 730, 308, 194, 0, 342, 422, 536],
+  [468, 1016, 788, 1164, 1050, 514, 514, 662, 320, 274, 388, 650, 536, 342, 0, 764, 194],
+  [776, 868, 1552, 560, 674, 1050, 1278, 742, 1084, 810, 1152, 274, 388, 422, 764, 0, 798],
+  [662, 1210, 754, 1358, 1244, 708, 480, 856, 514, 468, 354, 844, 730, 536, 194, 798, 0]
+]
+data[:pickups_deliveries] = [
+  [1, 6],
+  [2, 10],
+  [4, 3],
+  [5, 9],
+  [7, 8],
+  [15, 11],
+  [13, 12],
+  [16, 14],
+]
+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|
+  from_node = manager.index_to_node(from_index)
+  to_node = manager.index_to_node(to_index)
+  data[: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)
+
+dimension_name = "Distance"
+routing.add_dimension(
+  transit_callback_index,
+  0,  # no slack
+  3000,  # vehicle maximum travel distance
+  true,  # start cumul to zero
+  dimension_name
+)
+distance_dimension = routing.mutable_dimension(dimension_name)
+distance_dimension.global_span_cost_coefficient = 100
+
+data[:pickups_deliveries].each do |request|
+  pickup_index = manager.node_to_index(request[0])
+  delivery_index = manager.node_to_index(request[1])
+  routing.add_pickup_and_delivery(pickup_index, delivery_index)
+  routing.solver.add(routing.vehicle_var(pickup_index) == routing.vehicle_var(delivery_index))
+  routing.solver.add(distance_dimension.cumul_var(pickup_index) <= distance_dimension.cumul_var(delivery_index))
+end
+
+solution = routing.solve(first_solution_strategy: :parallel_cheapest_insertion)
+
+total_distance = 0
+data[:num_vehicles].times do |vehicle_id|
+  index = routing.start(vehicle_id)
+  plan_output = String.new("Route for vehicle #{vehicle_id}:\n")
+  route_distance = 0
+  while !routing.end?(index)
+    plan_output += " #{manager.index_to_node(index)} -> "
+    previous_index = index
+    index = solution.value(routing.next_var(index))
+    route_distance += routing.arc_cost_for_vehicle(previous_index, index, vehicle_id)
+  end
+  plan_output += "#{manager.index_to_node(index)}\n"
+  plan_output += "Distance of the route: #{route_distance}m\n\n"
+  puts plan_output
+  total_distance += route_distance
+end
+puts "Total Distance of all routes: #{total_distance}m"
+```
+
+### Time Window Constraints
+
+[Guide](https://developers.google.com/optimization/routing/vrptw)
+
+```ruby
+data = {}
+data[:time_matrix] = [
+  [0, 6, 9, 8, 7, 3, 6, 2, 3, 2, 6, 6, 4, 4, 5, 9, 7],
+  [6, 0, 8, 3, 2, 6, 8, 4, 8, 8, 13, 7, 5, 8, 12, 10, 14],
+  [9, 8, 0, 11, 10, 6, 3, 9, 5, 8, 4, 15, 14, 13, 9, 18, 9],
+  [8, 3, 11, 0, 1, 7, 10, 6, 10, 10, 14, 6, 7, 9, 14, 6, 16],
+  [7, 2, 10, 1, 0, 6, 9, 4, 8, 9, 13, 4, 6, 8, 12, 8, 14],
+  [3, 6, 6, 7, 6, 0, 2, 3, 2, 2, 7, 9, 7, 7, 6, 12, 8],
+  [6, 8, 3, 10, 9, 2, 0, 6, 2, 5, 4, 12, 10, 10, 6, 15, 5],
+  [2, 4, 9, 6, 4, 3, 6, 0, 4, 4, 8, 5, 4, 3, 7, 8, 10],
+  [3, 8, 5, 10, 8, 2, 2, 4, 0, 3, 4, 9, 8, 7, 3, 13, 6],
+  [2, 8, 8, 10, 9, 2, 5, 4, 3, 0, 4, 6, 5, 4, 3, 9, 5],
+  [6, 13, 4, 14, 13, 7, 4, 8, 4, 4, 0, 10, 9, 8, 4, 13, 4],
+  [6, 7, 15, 6, 4, 9, 12, 5, 9, 6, 10, 0, 1, 3, 7, 3, 10],
+  [4, 5, 14, 7, 6, 7, 10, 4, 8, 5, 9, 1, 0, 2, 6, 4, 8],
+  [4, 8, 13, 9, 8, 7, 10, 3, 7, 4, 8, 3, 2, 0, 4, 5, 6],
+  [5, 12, 9, 14, 12, 6, 6, 7, 3, 3, 4, 7, 6, 4, 0, 9, 2],
+  [9, 10, 18, 6, 8, 12, 15, 8, 13, 9, 13, 3, 4, 5, 9, 0, 9],
+  [7, 14, 9, 16, 14, 8, 5, 10, 6, 5, 4, 10, 8, 6, 2, 9, 0],
+]
+data[:time_windows] = [
+  [0, 5],  # depot
+  [7, 12],  # 1
+  [10, 15],  # 2
+  [16, 18],  # 3
+  [10, 13],  # 4
+  [0, 5],  # 5
+  [5, 10],  # 6
+  [0, 4],  # 7
+  [5, 10],  # 8
+  [0, 3],  # 9
+  [10, 16],  # 10
+  [10, 15],  # 11
+  [0, 5],  # 12
+  [5, 10],  # 13
+  [7, 8],  # 14
+  [10, 15],  # 15
+  [11, 15],  # 16
+]
+data[:num_vehicles] = 4
+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|
+  from_node = manager.index_to_node(from_index)
+  to_node = manager.index_to_node(to_index)
+  data[:time_matrix][from_node][to_node]
+end
+
+transit_callback_index = routing.register_transit_callback(time_callback)
+routing.set_arc_cost_evaluator_of_all_vehicles(transit_callback_index)
+time = "Time"
+routing.add_dimension(
+  transit_callback_index,
+  30,  # allow waiting time
+  30,  # maximum time per vehicle
+  false,  # don't force start cumul to zero
+  time
+)
+time_dimension = routing.mutable_dimension(time)
+
+data[:time_windows].each_with_index do |time_window, location_idx|
+  next if location_idx == 0
+  index = manager.node_to_index(location_idx)
+  time_dimension.cumul_var(index).set_range(time_window[0], time_window[1])
+end
+
+data[:num_vehicles].times do |vehicle_id|
+  index = routing.start(vehicle_id)
+  time_dimension.cumul_var(index).set_range(data[:time_windows][0][0], data[:time_windows][0][1])
+end
+
+data[:num_vehicles].times do |i|
+  routing.add_variable_minimized_by_finalizer(time_dimension.cumul_var(routing.start(i)))
+  routing.add_variable_minimized_by_finalizer(time_dimension.cumul_var(routing.end(i)))
+end
+
+solution = routing.solve(first_solution_strategy: :path_cheapest_arc)
+
+time_dimension = routing.mutable_dimension("Time")
+total_time = 0
+data[:num_vehicles].times do |vehicle_id|
+  index = routing.start(vehicle_id)
+  plan_output = String.new("Route for vehicle #{vehicle_id}:\n")
+  while !routing.end?(index)
+    time_var = time_dimension.cumul_var(index)
+    plan_output += "#{manager.index_to_node(index)} Time(#{solution.min(time_var)},#{solution.max(time_var)}) -> "
+    index = solution.value(routing.next_var(index))
+  end
+  time_var = time_dimension.cumul_var(index)
+  plan_output += "#{manager.index_to_node(index)} Time(#{solution.min(time_var)},#{solution.max(time_var)})\n"
+  plan_output += "Time of the route: #{solution.min(time_var)}min\n\n"
+  puts plan_output
+  total_time += solution.min(time_var)
+end
+puts "Total time of all routes: #{total_time}min"
+```
+
+### Resource Constraints
+
+[Guide](https://developers.google.com/optimization/routing/cvrptw_resources)
+
+```ruby
+data = {}
+data[:time_matrix] = [
+  [0, 6, 9, 8, 7, 3, 6, 2, 3, 2, 6, 6, 4, 4, 5, 9, 7],
+  [6, 0, 8, 3, 2, 6, 8, 4, 8, 8, 13, 7, 5, 8, 12, 10, 14],
+  [9, 8, 0, 11, 10, 6, 3, 9, 5, 8, 4, 15, 14, 13, 9, 18, 9],
+  [8, 3, 11, 0, 1, 7, 10, 6, 10, 10, 14, 6, 7, 9, 14, 6, 16],
+  [7, 2, 10, 1, 0, 6, 9, 4, 8, 9, 13, 4, 6, 8, 12, 8, 14],
+  [3, 6, 6, 7, 6, 0, 2, 3, 2, 2, 7, 9, 7, 7, 6, 12, 8],
+  [6, 8, 3, 10, 9, 2, 0, 6, 2, 5, 4, 12, 10, 10, 6, 15, 5],
+  [2, 4, 9, 6, 4, 3, 6, 0, 4, 4, 8, 5, 4, 3, 7, 8, 10],
+  [3, 8, 5, 10, 8, 2, 2, 4, 0, 3, 4, 9, 8, 7, 3, 13, 6],
+  [2, 8, 8, 10, 9, 2, 5, 4, 3, 0, 4, 6, 5, 4, 3, 9, 5],
+  [6, 13, 4, 14, 13, 7, 4, 8, 4, 4, 0, 10, 9, 8, 4, 13, 4],
+  [6, 7, 15, 6, 4, 9, 12, 5, 9, 6, 10, 0, 1, 3, 7, 3, 10],
+  [4, 5, 14, 7, 6, 7, 10, 4, 8, 5, 9, 1, 0, 2, 6, 4, 8],
+  [4, 8, 13, 9, 8, 7, 10, 3, 7, 4, 8, 3, 2, 0, 4, 5, 6],
+  [5, 12, 9, 14, 12, 6, 6, 7, 3, 3, 4, 7, 6, 4, 0, 9, 2],
+  [9, 10, 18, 6, 8, 12, 15, 8, 13, 9, 13, 3, 4, 5, 9, 0, 9],
+  [7, 14, 9, 16, 14, 8, 5, 10, 6, 5, 4, 10, 8, 6, 2, 9, 0]
+]
+data[:time_windows] = [
+  [0, 5],  # depot
+  [7, 12],  # 1
+  [10, 15],  # 2
+  [5, 14],  # 3
+  [5, 13],  # 4
+  [0, 5],  # 5
+  [5, 10],  # 6
+  [0, 10],  # 7
+  [5, 10],  # 8
+  [0, 5],  # 9
+  [10, 16],  # 10
+  [10, 15],  # 11
+  [0, 5],  # 12
+  [5, 10],  # 13
+  [7, 12],  # 14
+  [10, 15],  # 15
+  [5, 15],  # 16
+]
+data[:num_vehicles] = 4
+data[:vehicle_load_time] = 5
+data[:vehicle_unload_time] = 5
+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|
+  from_node = manager.index_to_node(from_index)
+  to_node = manager.index_to_node(to_index)
+  data[:time_matrix][from_node][to_node]
+end
+
+transit_callback_index = routing.register_transit_callback(time_callback)
+
+routing.set_arc_cost_evaluator_of_all_vehicles(transit_callback_index)
+
+time = "Time"
+routing.add_dimension(
+  transit_callback_index,
+  60,  # allow waiting time
+  60,  # maximum time per vehicle
+  false,  # don't force start cumul to zero
+  time
+)
+time_dimension = routing.mutable_dimension(time)
+data[:time_windows].each_with_index do |time_window, location_idx|
+  next if location_idx == 0
+  index = manager.node_to_index(location_idx)
+  time_dimension.cumul_var(index).set_range(time_window[0], time_window[1])
+end
+
+data[:num_vehicles].times do |vehicle_id|
+  index = routing.start(vehicle_id)
+  time_dimension.cumul_var(index).set_range(data[:time_windows][0][0], data[:time_windows][0][1])
+end
+
+solver = routing.solver
+intervals = []
+data[:num_vehicles].times do |i|
+  intervals << solver.fixed_duration_interval_var(
+    time_dimension.cumul_var(routing.start(i)),
+    data[:vehicle_load_time],
+    "depot_interval"
+  )
+  intervals << solver.fixed_duration_interval_var(
+    time_dimension.cumul_var(routing.end(i)),
+    data[:vehicle_unload_time],
+    "depot_interval"
+  )
+end
+
+depot_usage = [1] * intervals.size
+solver.add(solver.cumulative(intervals, depot_usage, data[:depot_capacity], "depot"))
+
+data[:num_vehicles].times do |i|
+  routing.add_variable_minimized_by_finalizer(time_dimension.cumul_var(routing.start(i)))
+  routing.add_variable_minimized_by_finalizer(time_dimension.cumul_var(routing.end(i)))
+end
+
+solution = routing.solve(first_solution_strategy: :path_cheapest_arc)
+
+time_dimension = routing.mutable_dimension("Time")
+total_time = 0
+data[:num_vehicles].times do |vehicle_id|
+  index = routing.start(vehicle_id)
+  plan_output = String.new("Route for vehicle #{vehicle_id}:\n")
+  while !routing.end?(index)
+    time_var = time_dimension.cumul_var(index)
+    plan_output += "#{manager.index_to_node(index)} Time(#{solution.min(time_var)},#{solution.max(time_var)}) -> "
+    index = solution.value(routing.next_var(index))
+  end
+  time_var = time_dimension.cumul_var(index)
+  plan_output += "#{manager.index_to_node(index)} Time(#{solution.min(time_var)},#{solution.max(time_var)})\n"
+  plan_output += "Time of the route: #{solution.min(time_var)}min\n\n"
+  puts plan_output
+  total_time += solution.min(time_var)
+end
+puts "Total time of all routes: #{total_time}min"
+```
+
+### Penalties and Dropping Visits
+
+[Guide](https://developers.google.com/optimization/routing/penalties)
+
+```ruby
+data = {}
+data[:distance_matrix] = [
+  [0, 548, 776, 696, 582, 274, 502, 194, 308, 194, 536, 502, 388, 354, 468, 776, 662],
+  [548, 0, 684, 308, 194, 502, 730, 354, 696, 742, 1084, 594, 480, 674, 1016, 868, 1210],
+  [776, 684, 0, 992, 878, 502, 274, 810, 468, 742, 400, 1278, 1164, 1130, 788, 1552, 754],
+  [696, 308, 992, 0, 114, 650, 878, 502, 844, 890, 1232, 514, 628, 822, 1164, 560, 1358],
+  [582, 194, 878, 114, 0, 536, 764, 388, 730, 776, 1118, 400, 514, 708, 1050, 674, 1244],
+  [274, 502, 502, 650, 536, 0, 228, 308, 194, 240, 582, 776, 662, 628, 514, 1050, 708],
+  [502, 730, 274, 878, 764, 228, 0, 536, 194, 468, 354, 1004, 890, 856, 514, 1278, 480],
+  [194, 354, 810, 502, 388, 308, 536, 0, 342, 388, 730, 468, 354, 320, 662, 742, 856],
+  [308, 696, 468, 844, 730, 194, 194, 342, 0, 274, 388, 810, 696, 662, 320, 1084, 514],
+  [194, 742, 742, 890, 776, 240, 468, 388, 274, 0, 342, 536, 422, 388, 274, 810, 468],
+  [536, 1084, 400, 1232, 1118, 582, 354, 730, 388, 342, 0, 878, 764, 730, 388, 1152, 354],
+  [502, 594, 1278, 514, 400, 776, 1004, 468, 810, 536, 878, 0, 114, 308, 650, 274, 844],
+  [388, 480, 1164, 628, 514, 662, 890, 354, 696, 422, 764, 114, 0, 194, 536, 388, 730],
+  [354, 674, 1130, 822, 708, 628, 856, 320, 662, 388, 730, 308, 194, 0, 342, 422, 536],
+  [468, 1016, 788, 1164, 1050, 514, 514, 662, 320, 274, 388, 650, 536, 342, 0, 764, 194],
+  [776, 868, 1552, 560, 674, 1050, 1278, 742, 1084, 810, 1152, 274, 388, 422, 764, 0, 798],
+  [662, 1210, 754, 1358, 1244, 708, 480, 856, 514, 468, 354, 844, 730, 536, 194, 798, 0]
+]
+data[:demands] = [0, 1, 1, 3, 6, 3, 6, 8, 8, 1, 2, 1, 2, 6, 6, 8, 8]
+data[:vehicle_capacities] = [15, 15, 15, 15]
+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|
+  from_node = manager.index_to_node(from_index)
+  to_node = manager.index_to_node(to_index)
+  data[: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)
+
+demand_callback = lambda do |from_index|
+  from_node = manager.index_to_node(from_index)
+  data[:demands][from_node]
+end
+
+demand_callback_index = routing.register_unary_transit_callback(demand_callback)
+routing.add_dimension_with_vehicle_capacity(
+  demand_callback_index,
+  0,  # null capacity slack
+  data[:vehicle_capacities],  # vehicle maximum capacities
+  true,  # start cumul to zero
+  "Capacity"
+)
+
+penalty = 1000
+1.upto(data[:distance_matrix].size - 1) do |node|
+  routing.add_disjunction([manager.node_to_index(node)], penalty)
+end
+
+assignment = routing.solve(first_solution_strategy: :path_cheapest_arc)
+
+dropped_nodes = String.new("Dropped nodes:")
+routing.size.times do |node|
+  next if routing.start?(node) || routing.end?(node)
+
+  if assignment.value(routing.next_var(node)) == node
+    dropped_nodes += " #{manager.index_to_node(node)}"
+  end
+end
+puts dropped_nodes
+
+total_distance = 0
+total_load = 0
+data[:num_vehicles].times do |vehicle_id|
+  index = routing.start(vehicle_id)
+  plan_output = "Route for vehicle #{vehicle_id}:\n"
+  route_distance = 0
+  route_load = 0
+  while !routing.end?(index)
+    node_index = manager.index_to_node(index)
+    route_load += data[:demands][node_index]
+    plan_output += " #{node_index} Load(#{route_load}) -> "
+    previous_index = index
+    index = assignment.value(routing.next_var(index))
+    route_distance += routing.arc_cost_for_vehicle(previous_index, index, vehicle_id)
+  end
+  plan_output += " #{manager.index_to_node(index)} Load(#{route_load})\n"
+  plan_output += "Distance of the route: #{route_distance}m\n"
+  plan_output += "Load of the route: #{route_load}\n\n"
+  puts plan_output
+  total_distance += route_distance
+  total_load += route_load
+end
+puts "Total Distance of all routes: #{total_distance}m"
+puts "Total Load of all routes: #{total_load}"
+```
+
 ### Routing Options
 
 [Guide](https://developers.google.com/optimization/routing/routing_options)
@@ -1085,6 +1747,133 @@ puts "  - wall time       : %f s" % solver.wall_time
 puts "  - solutions found : %i" % solution_printer.solution_count
 ```
 
+## Sudoku
+
+[Example](https://github.com/google/or-tools/blob/stable/examples/python/sudoku_sat.py)
+
+```ruby
+# create the model
+model = ORTools::CpModel.new
+
+cell_size = 3
+line_size = cell_size**2
+line = (0...line_size).to_a
+cell = (0...cell_size).to_a
+
+initial_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]
+]
+
+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
+
+# all different on rows
+line.each do |i|
+  model.add_all_different(line.map { |j| grid[[i, j]] })
+end
+
+# all different on columns
+line.each do |j|
+  model.add_all_different(line.map { |i| grid[[i, j]] })
+end
+
+# all different on cells
+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
+
+# initial values
+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
+
+# solve and print solution
+solver = ORTools::CpSolver.new
+status = solver.solve(model)
+if status == :feasible
+  line.each do |i|
+    p line.map { |j| solver.value(grid[[i, j]]) }
+  end
+end
+```
+
+## Set Partitioning
+
+[Example](https://pythonhosted.org/PuLP/CaseStudies/a_set_partitioning_problem.html)
+
+```ruby
+# A set partitioning model of a wedding seating problem
+# Authors: Stuart Mitchell 2009
+
+max_tables = 5
+max_table_size = 4
+guests = %w(A B C D E F G I J K L M N O P Q R)
+
+# Find the happiness of the table
+# by calculating the maximum distance between the letters
+def happiness(table)
+  (table[0].ord - table[-1].ord).abs
+end
+
+# create list of all possible tables
+possible_tables = []
+(1..max_table_size).each do |i|
+  possible_tables += guests.combination(i).to_a
+end
+
+solver = ORTools::Solver.new("Wedding Seating Model", :cbc)
+
+# create a binary variable to state that a table setting is used
+x = {}
+possible_tables.each do |table|
+  x[table] = solver.int_var(0, 1, "table #{table.join(", ")}")
+end
+
+solver.minimize(solver.sum(possible_tables.map { |table| x[table] * happiness(table) }))
+
+# specify the maximum number of tables
+solver.add(solver.sum(x.values) <= max_tables)
+
+# a guest must seated at one and only one table
+guests.each do |guest|
+  tables_with_guest = possible_tables.select { |table| table.include?(guest) }
+  solver.add(solver.sum(tables_with_guest.map { |table| x[table] }) == 1)
+end
+
+status = solver.solve
+
+puts "The chosen tables are out of a total of %s:" % possible_tables.size
+possible_tables.each do |table|
+  if x[table].solution_value == 1
+    p table
+  end
+end
+```
+
 ## History
 
 View the [changelog](https://github.com/ankane/or-tools/blob/master/CHANGELOG.md)

data/ext/or-tools/ext.cpp

@@ -115,8 +115,11 @@ operations_research::sat::LinearExpr from_ruby<operations_research::sat::LinearE
       auto cvar = (Array) var;
       // TODO clean up
       Object o = cvar[0];
-      if (((Rice::String) o.call("class").call("name")).str() == "ORTools::BoolVar") {
+      std::string type = ((String) o.call("class").call("name")).str();
+      if (type == "ORTools::BoolVar") {
         expr.AddVar(from_ruby<operations_research::sat::BoolVar>(cvar[0]));
+      } else if (type == "Integer") {
+        expr.AddConstant(from_ruby<int64>(cvar[0]));
       } else {
         expr.AddTerm(from_ruby<operations_research::sat::IntVar>(cvar[0]), from_ruby<int64>(cvar[1]));
       }
@@ -141,13 +144,22 @@ class Assignment {
     int64 Value(const operations_research::IntVar* const var) const {
       return self->Value(var);
     }
+    int64 Min(const operations_research::IntVar* const var) const {
+      return self->Min(var);
+    }
+    int64 Max(const operations_research::IntVar* const var) const {
+      return self->Max(var);
+    }
 };
 
 Class rb_cMPVariable;
 Class rb_cMPConstraint;
 Class rb_cMPObjective;
 Class rb_cIntVar;
+Class rb_cIntervalVar;
 Class rb_cRoutingDimension;
+Class rb_cConstraint;
+Class rb_cSolver2;
 
 template<>
 inline
@@ -177,6 +189,13 @@ Object to_ruby<operations_research::IntVar*>(operations_research::IntVar* const
   return Rice::Data_Object<operations_research::IntVar>(x, rb_cIntVar, nullptr, nullptr);
 }
 
+template<>
+inline
+Object to_ruby<operations_research::IntervalVar*>(operations_research::IntervalVar* const &x)
+{
+  return Rice::Data_Object<operations_research::IntervalVar>(x, rb_cIntervalVar, nullptr, nullptr);
+}
+
 template<>
 inline
 Object to_ruby<RoutingDimension*>(RoutingDimension* const &x)
@@ -184,6 +203,42 @@ Object to_ruby<RoutingDimension*>(RoutingDimension* const &x)
   return Rice::Data_Object<RoutingDimension>(x, rb_cRoutingDimension, nullptr, nullptr);
 }
 
+template<>
+inline
+Object to_ruby<operations_research::Constraint*>(operations_research::Constraint* const &x)
+{
+  return Rice::Data_Object<operations_research::Constraint>(x, rb_cConstraint, nullptr, nullptr);
+}
+
+template<>
+inline
+Object to_ruby<operations_research::Solver*>(operations_research::Solver* const &x)
+{
+  return Rice::Data_Object<operations_research::Solver>(x, rb_cSolver2, nullptr, nullptr);
+}
+
+// need a wrapper class since absl::Span doesn't own
+class IntVarSpan {
+  std::vector<operations_research::sat::IntVar> vec;
+  public:
+    IntVarSpan(Object x) {
+      Array a = Array(x);
+      for (std::size_t i = 0; i < a.size(); ++i) {
+        vec.push_back(from_ruby<operations_research::sat::IntVar>(a[i]));
+      }
+    }
+    operator absl::Span<const operations_research::sat::IntVar>() {
+      return absl::Span<const operations_research::sat::IntVar>(vec);
+    }
+};
+
+template<>
+inline
+IntVarSpan from_ruby<IntVarSpan>(Object x)
+{
+  return IntVarSpan(x);
+}
+
 extern "C"
 void Init_ext()
 {
@@ -293,6 +348,11 @@ void Init_ext()
       *[](MPVariable& self, double other) {
         LinearExpr s(&self);
         return s * other;
+      })
+    .define_method(
+      "inspect",
+      *[](MPVariable& self) {
+        return "#<ORTools::MPVariable @name=\"" + self.name() + "\">";
       });
 
   define_class_under<LinearExpr>(rb_mORTools, "LinearExpr")
@@ -402,7 +462,9 @@ void Init_ext()
       });
 
   // not to be confused with operations_research::IntVar
-  define_class_under<operations_research::sat::IntVar>(rb_mORTools, "SatIntVar");
+  define_class_under<operations_research::sat::IntVar>(rb_mORTools, "SatIntVar")
+    .define_method("name", &operations_research::sat::IntVar::Name);
+
   define_class_under<BoolVar>(rb_mORTools, "BoolVar")
     .define_method("name", &BoolVar::Name)
     .define_method("index", &BoolVar::index)
@@ -456,6 +518,11 @@ void Init_ext()
       *[](CpModelBuilder& self, operations_research::sat::LinearExpr x, operations_research::sat::LinearExpr y) {
         self.AddLessOrEqual(x, y);
       })
+    .define_method(
+      "add_all_different",
+      *[](CpModelBuilder& self, IntVarSpan vars) {
+        self.AddAllDifferent(vars);
+      })
     .define_method(
       "maximize",
       *[](CpModelBuilder& self, operations_research::sat::LinearExpr expr) {
@@ -503,7 +570,12 @@ void Init_ext()
     .define_method("num_conflicts", &CpSolverResponse::num_conflicts)
     .define_method("num_branches", &CpSolverResponse::num_branches)
     .define_method("wall_time", &CpSolverResponse::wall_time)
-    // .define_method("solution_integer_value", &SolutionIntegerValue)
+    .define_method(
+      "solution_integer_value",
+      *[](CpSolverResponse& self, operations_research::sat::IntVar& x) {
+        operations_research::sat::LinearExpr expr(x);
+        return SolutionIntegerValue(self, expr);
+      })
     .define_method("solution_boolean_value", &operations_research::sat::SolutionBooleanValue)
     .define_method(
       "status",
@@ -525,17 +597,72 @@ void Init_ext()
 
   define_class_under<RoutingIndexManager>(rb_mORTools, "RoutingIndexManager")
     .define_constructor(Constructor<RoutingIndexManager, int, int, RoutingNodeIndex>())
-    .define_method("index_to_node", &RoutingIndexManager::IndexToNode);
+    .define_method("index_to_node", &RoutingIndexManager::IndexToNode)
+    .define_method("node_to_index", &RoutingIndexManager::NodeToIndex);
 
   define_class_under<Assignment>(rb_mORTools, "Assignment")
     .define_method("objective_value", &Assignment::ObjectiveValue)
-    .define_method("value", &Assignment::Value);
+    .define_method("value", &Assignment::Value)
+    .define_method("min", &Assignment::Min)
+    .define_method("max", &Assignment::Max);
 
   // not to be confused with operations_research::sat::IntVar
-  rb_cIntVar = define_class_under<operations_research::IntVar>(rb_mORTools, "IntVar");
+  rb_cIntVar = define_class_under<operations_research::IntVar>(rb_mORTools, "IntVar")
+    .define_method(
+      "set_range",
+      *[](operations_research::IntVar& self, int64 new_min, int64 new_max) {
+        self.SetRange(new_min, new_max);
+      });
+
+  rb_cIntervalVar = define_class_under<operations_research::IntervalVar>(rb_mORTools, "IntervalVar");
 
   rb_cRoutingDimension = define_class_under<RoutingDimension>(rb_mORTools, "RoutingDimension")
-    .define_method("global_span_cost_coefficient=", &RoutingDimension::SetGlobalSpanCostCoefficient);
+    .define_method("global_span_cost_coefficient=", &RoutingDimension::SetGlobalSpanCostCoefficient)
+    .define_method("cumul_var", &RoutingDimension::CumulVar);
+
+  rb_cConstraint = define_class_under<operations_research::Constraint>(rb_mORTools, "Constraint");
+
+  rb_cSolver2 = define_class_under<operations_research::Solver>(rb_mORTools, "Solver2")
+    .define_method(
+      "add",
+      *[](operations_research::Solver& self, Object o) {
+        operations_research::Constraint* constraint;
+        if (o.respond_to("left")) {
+          operations_research::IntExpr* left(from_ruby<operations_research::IntVar*>(o.call("left")));
+          operations_research::IntExpr* right(from_ruby<operations_research::IntVar*>(o.call("right")));
+          auto op = o.call("operator").to_s().str();
+          if (op == "==") {
+            constraint = self.MakeEquality(left, right);
+          } else if (op == "<=") {
+            constraint = self.MakeLessOrEqual(left, right);
+          } else {
+            throw std::runtime_error("Unknown operator");
+          }
+        } else {
+          constraint = from_ruby<operations_research::Constraint*>(o);
+        }
+        self.AddConstraint(constraint);
+      })
+    .define_method(
+      "fixed_duration_interval_var",
+      *[](operations_research::Solver& self, operations_research::IntVar* const start_variable, int64 duration, const std::string& name) {
+        return self.MakeFixedDurationIntervalVar(start_variable, duration, name);
+      })
+    .define_method(
+      "cumulative",
+      *[](operations_research::Solver& self, Array rb_intervals, Array rb_demands, int64 capacity, const std::string& name) {
+        std::vector<operations_research::IntervalVar*> intervals;
+        for (std::size_t i = 0; i < rb_intervals.size(); ++i) {
+          intervals.push_back(from_ruby<operations_research::IntervalVar*>(rb_intervals[i]));
+        }
+
+        std::vector<int64> demands;
+        for (std::size_t i = 0; i < rb_demands.size(); ++i) {
+          demands.push_back(from_ruby<int64>(rb_demands[i]));
+        }
+
+        return self.MakeCumulative(intervals, demands, capacity, name);
+      });
 
   define_class_under<RoutingModel>(rb_mORTools, "RoutingModel")
     .define_constructor(Constructor<RoutingModel, RoutingIndexManager>())
@@ -548,13 +675,44 @@ void Init_ext()
           }
         );
       })
+    .define_method(
+      "register_unary_transit_callback",
+      *[](RoutingModel& self, Object callback) {
+        return self.RegisterUnaryTransitCallback(
+          [callback](int64 from_index) -> int64 {
+            return from_ruby<int64>(callback.call("call", from_index));
+          }
+        );
+      })
     .define_method("depot", &RoutingModel::GetDepot)
+    .define_method("size", &RoutingModel::Size)
+    .define_method("vehicle_var", &RoutingModel::VehicleVar)
     .define_method("set_arc_cost_evaluator_of_all_vehicles", &RoutingModel::SetArcCostEvaluatorOfAllVehicles)
     .define_method("set_arc_cost_evaluator_of_vehicle", &RoutingModel::SetArcCostEvaluatorOfVehicle)
     .define_method("set_fixed_cost_of_all_vehicles", &RoutingModel::SetFixedCostOfAllVehicles)
     .define_method("set_fixed_cost_of_vehicle", &RoutingModel::SetFixedCostOfVehicle)
     .define_method("fixed_cost_of_vehicle", &RoutingModel::GetFixedCostOfVehicle)
     .define_method("add_dimension", &RoutingModel::AddDimension)
+    .define_method(
+      "add_dimension_with_vehicle_capacity",
+      *[](RoutingModel& self, int evaluator_index, int64 slack_max, Array vc, bool fix_start_cumul_to_zero, const std::string& name) {
+        std::vector<int64> vehicle_capacities;
+        for (std::size_t i = 0; i < vc.size(); ++i) {
+          vehicle_capacities.push_back(from_ruby<int64>(vc[i]));
+        }
+        self.AddDimensionWithVehicleCapacity(evaluator_index, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name);
+      })
+    .define_method(
+      "add_disjunction",
+      *[](RoutingModel& self, Array rb_indices, int64 penalty) {
+        std::vector<int64> indices;
+        for (std::size_t i = 0; i < rb_indices.size(); ++i) {
+          indices.push_back(from_ruby<int64>(rb_indices[i]));
+        }
+        self.AddDisjunction(indices, penalty);
+      })
+    .define_method("add_pickup_and_delivery", &RoutingModel::AddPickupAndDelivery)
+    .define_method("solver", &RoutingModel::solver)
     .define_method("start", &RoutingModel::Start)
     .define_method("end", &RoutingModel::End)
     .define_method("start?", &RoutingModel::IsStart)
@@ -565,6 +723,7 @@ void Init_ext()
     .define_method("next_var", &RoutingModel::NextVar)
     .define_method("arc_cost_for_vehicle", &RoutingModel::GetArcCostForVehicle)
     .define_method("mutable_dimension", &RoutingModel::GetMutableDimension)
+    .define_method("add_variable_minimized_by_finalizer", &RoutingModel::AddVariableMinimizedByFinalizer)
     .define_method(
       "solve_with_parameters",
       *[](RoutingModel& self, const RoutingSearchParameters& search_parameters) {

data/lib/or-tools.rb

@@ -7,6 +7,7 @@ require "or_tools/comparison_operators"
 require "or_tools/cp_model"
 require "or_tools/cp_solver"
 require "or_tools/cp_solver_solution_callback"
+require "or_tools/int_var"
 require "or_tools/knapsack_solver"
 require "or_tools/linear_expr"
 require "or_tools/routing_model"

data/lib/or_tools/cp_solver_solution_callback.rb

@@ -3,7 +3,14 @@ module ORTools
     attr_writer :response
 
     def value(expr)
-      @response.solution_boolean_value(expr)
+      case expr
+      when SatIntVar
+        @response.solution_integer_value(expr)
+      when BoolVar
+        @response.solution_boolean_value(expr)
+      else
+        raise "Unsupported type"
+      end
     end
   end
 end

data/lib/or_tools/int_var.rb

@@ -0,0 +1,5 @@
+module ORTools
+  class IntVar
+    include ComparisonOperators
+  end
+end

data/lib/or_tools/sat_int_var.rb

@@ -5,5 +5,18 @@ module ORTools
     def *(other)
       SatLinearExpr.new([[self, other]])
     end
+
+    def +(other)
+      SatLinearExpr.new([[self, 1], [other, 1]])
+    end
+
+    def -(other)
+      SatLinearExpr.new([[self, 1], [-other, 1]])
+    end
+
+    # for now
+    def inspect
+      name
+    end
   end
 end

data/lib/or_tools/sat_linear_expr.rb

@@ -16,8 +16,24 @@ module ORTools
       add(other, -1)
     end
 
+    def *(other)
+      if vars.size == 1
+        self.class.new([[vars[0][0], vars[0][1] * other]])
+      else
+        raise ArgumentError, "Multiplication not allowed here"
+      end
+    end
+
     def inspect
-      vars.map { |v| v[0].is_a?(BoolVar) ? v[0].name : v[0].name + " * " + v[1] }.join(" + ")
+      vars.map do |v|
+        k = v[0]
+        k = k.respond_to?(:name) ? k.name : k.inspect
+        if v[1] == 1
+          k
+        else
+          "#{k} * #{v[1]}"
+        end
+      end.join(" + ").sub(" + -", " - ")
     end
 
     private
@@ -27,7 +43,7 @@ module ORTools
         case other
         when SatLinearExpr
           other.vars
-        when BoolVar
+        when BoolVar, SatIntVar
           [[other, 1]]
         else
           raise ArgumentError, "Unsupported type"

data/lib/or_tools/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: or-tools
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-18 00:00:00.000000000 Z
+date: 2020-03-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rice
@@ -100,6 +100,7 @@ files:
 - 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