or-tools 0.7.0 → 0.7.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 03544e925041f7337e6e6ba1b00b6d6c4d97353bcd7ee3785a46959a952bf09c
-  data.tar.gz: eddbab6814900afc7ddda651da92a53aa06b0db857659ab2ccd1c1adb9770fe0
+  metadata.gz: 976e5d3e7d64ac20e1d445baa12720acd4e91469d1fddbaf8c71cf32e1bb7be6
+  data.tar.gz: 38d1b76452dc3df179cc7536e466846bf6030dfcd1da283393cbfa3c9c68b4b6
 SHA512:
-  metadata.gz: '041939b99da310567a099f7654658697b93e36436abf06779336ca51e0d02be94473c0474d238041285975f293734cde65c37e5db565b8f30b49f856fe519100'
-  data.tar.gz: '09f6a2f0701acb005f356555df0d0e19befe36090d4de1b2188e7944a55836c80022eed5d4e185dc3b3b016c9c73fa3d5957e8c3cf8adf83bf4773b1090e5f0a'
+  metadata.gz: 2612839346ab70b75cb4f307ae2116816a4638580a1e943e3c09247af4ff0e27177549ae2c170aa1b67d6453922883265c7c7c93d8dfbf573ec1bce650864bc6
+  data.tar.gz: 256087097f368c7c34d4affc531ef744184c897e99b0727f1c00a620644399de77b9c874e5cfc0f5a519552e965c55647146ad3b29346ebfd4ecc595a8d35068

data/CHANGELOG.md

@@ -1,3 +1,19 @@
+## 0.7.3 (2022-07-23)
+
+- Added more methods to `RoutingModel` and  `RoutingDimension`
+
+## 0.7.2 (2022-05-28)
+
+- Fixed library not loaded error on Mac
+
+## 0.7.1 (2022-05-27)
+
+- Added support for time limit for `Solver`
+- Added `enable_output` and `suppress_output` to `Solver`
+- Improved `new` method for `Solver`
+- Fixed error with offset with `Solver`
+- Fixed segfault with `CpSolver`
+
 ## 0.7.0 (2022-03-23)
 
 - Updated OR-Tools to 9.3

data/README.md

@@ -14,13 +14,73 @@ gem "or-tools"
 
 Installation can take a few minutes as OR-Tools downloads and builds. For Mac ARM, also follow [these instructions](#additional-instructions).
 
-## Higher Level Interfaces
+## Guides
+
+Higher Level Interfaces
 
 - [Scheduling](#scheduling)
 - [Seating](#seating)
 - [Traveling Salesperson Problem (TSP)](#traveling-salesperson-problem-tsp)
 - [Sudoku](#sudoku)
 
+Linear Optimization
+
+- [Solving an LP Problem](#solving-an-lp-problem)
+
+Integer Optimization
+
+- [Solving a MIP Problem](#solving-a-mip-problem)
+
+Constraint Optimization
+
+- [CP-SAT Solver](#cp-sat-solver)
+- [Solving a CP Problem](#solving-a-cp-problem)
+- [Cryptarithmetic](#cryptarithmetic)
+- [The N-queens Problem](#the-n-queens-problem)
+- [Setting Solver Limits](#setting-solver-limits)
+
+Assignment
+
+- [Solving an Assignment Problem](#solving-an-assignment-problem)
+- [Assignment with Teams of Workers](#assignment-with-teams-of-workers)
+- [Linear Sum Assignment Solver](#linear-sum-assignment-solver)
+
+Routing
+
+- [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)
+- [Time Window Constraints](#time-window-constraints)
+- [Resource Constraints](#resource-constraints)
+- [Penalties and Dropping Visits](#penalties-and-dropping-visits)
+- [Routing Options](#routing-options)
+
+Bin Packing
+
+- [The Knapsack Problem](#the-knapsack-problem)
+- [Multiple Knapsacks](#multiple-knapsacks)
+- [Bin Packing Problem](#bin-packing-problem)
+
+Network Flows
+
+- [Maximum Flows](#maximum-flows)
+- [Minimum Cost Flows](#minimum-cost-flows)
+- [Assignment as a Min Cost Flow Problem](#assignment-as-a-min-cost-flow-problem)
+
+Scheduling
+
+- [Employee Scheduling](#employee-scheduling)
+- [The Job Shop Problem](#the-job-shop-problem)
+
+Other Examples
+
+- [Sudoku](#sudoku-1)
+- [Wedding Seating Chart](#wedding-seating-chart)
+- [Set Partitioning](#set-partitioning)
+
+## Higher Level Interfaces
+
 ### Scheduling
 
 Specify people and their availabililty
@@ -251,138 +311,69 @@ sudoku = ORTools::Sudoku.new(grid, x: true, anti_knight: true, magic_square: tru
 sudoku.solution
 ```
 
-## Guides
+## Linear Optimization
 
-Linear Optimization
-
-- [The Glop Linear Solver](#the-glop-linear-solver)
+### Solving an LP Problem
 
-Integer Optimization
-
-- [Mixed-Integer Programming](#mixed-integer-programming)
-
-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)
-- [Setting Solver Limits](#setting-solver-limits)
-
-Assignment
-
-- [Assignment](#assignment)
-- [Assignment with Teams](#assignment-with-teams)
-
-Routing
-
-- [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)
-- [Time Window Constraints](#time-window-constraints)
-- [Resource Constraints](#resource-constraints)
-- [Penalties and Dropping Visits](#penalties-and-dropping-visits)
-- [Routing Options](#routing-options)
-
-Bin Packing
-
-- [The Knapsack Problem](#the-knapsack-problem)
-- [Multiple Knapsacks](#multiple-knapsacks)
-- [Bin Packing Problem](#bin-packing-problem)
-
-Network Flows
-
-- [Maximum Flows](#maximum-flows)
-- [Minimum Cost Flows](#minimum-cost-flows)
-- [Assignment as a Min Cost Flow Problem](#assignment-as-a-min-cost-flow-problem)
-
-Scheduling
-
-- [Employee Scheduling](#employee-scheduling)
-- [The Job Shop Problem](#the-job-shop-problem)
-
-Other Examples
-
-- [Sudoku](#sudoku-1)
-- [Wedding Seating Chart](#wedding-seating-chart)
-- [Set Partitioning](#set-partitioning)
-
-### The Glop Linear Solver
-
-[Guide](https://developers.google.com/optimization/lp/glop)
+[Guide](https://developers.google.com/optimization/lp/lp_example)
 
 ```ruby
 # declare the solver
-solver = ORTools::Solver.new("LinearProgrammingExample", :glop)
+solver = ORTools::Solver.new("GLOP")
 
 # create the variables
 x = solver.num_var(0, solver.infinity, "x")
 y = solver.num_var(0, solver.infinity, "y")
+puts "Number of variables = #{solver.num_variables}"
 
 # define the constraints
-constraint0 = solver.constraint(-solver.infinity, 14)
-constraint0.set_coefficient(x, 1)
-constraint0.set_coefficient(y, 2)
-
-constraint1 = solver.constraint(0, solver.infinity)
-constraint1.set_coefficient(x, 3)
-constraint1.set_coefficient(y, -1)
-
-constraint2 = solver.constraint(-solver.infinity, 2)
-constraint2.set_coefficient(x, 1)
-constraint2.set_coefficient(y, -1)
+solver.add(x + 2 * y <= 14)
+solver.add(3 * x - y >= 0)
+solver.add(x - y <= 2)
+puts "Number of constraints = #{solver.num_constraints}"
 
 # define the objective function
-objective = solver.objective
-objective.set_coefficient(x, 3)
-objective.set_coefficient(y, 4)
-objective.set_maximization
+solver.maximize(3 * x + 4 * y)
 
 # invoke the solver
-solver.solve
+status = solver.solve
 
 # 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}"
-puts "Solution:"
-puts "x = #{x.solution_value}"
-puts "y = #{y.solution_value}"
-puts "Optimal objective value = #{opt_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
 ```
 
-### Mixed-Integer Programming
+## Integer Optimization
 
-[Guide](https://developers.google.com/optimization/mip/integer_opt)
+### Solving a MIP Problem
+
+[Guide](https://developers.google.com/optimization/mip/mip_example)
 
 ```ruby
 # declare the MIP solver
-solver = ORTools::Solver.new("simple_mip_program", :cbc)
+solver = ORTools::Solver.new("CBC")
 
 # define the variables
 infinity = solver.infinity
-x = solver.int_var(0.0, infinity, "x")
-y = solver.int_var(0.0, infinity, "y")
+x = solver.int_var(0, infinity, "x")
+y = solver.int_var(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);
+solver.add(x + 7 * y <= 17.5)
+solver.add(x <= 3.5)
 
 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
+solver.maximize(x + 10 * y)
 
 # call the solver
 status = solver.solve
@@ -398,6 +389,8 @@ else
 end
 ```
 
+## Constraint Optimization
+
 ### CP-SAT Solver
 
 [Guide](https://developers.google.com/optimization/cp/cp_solver)
@@ -420,16 +413,18 @@ solver = ORTools::CpSolver.new
 status = solver.solve(model)
 
 # display the first solution
-if status == :optimal
+if status == :optimal || status == :feasible
   puts "x = #{solver.value(x)}"
   puts "y = #{solver.value(y)}"
   puts "z = #{solver.value(z)}"
+else
+  puts "No solution found."
 end
 ```
 
-### Solving an Optimization Problem
+### Solving a CP Problem
 
-[Guide](https://developers.google.com/optimization/cp/integer_opt_cp)
+[Guide](https://developers.google.com/optimization/cp/cp_example)
 
 ```ruby
 # declare the model
@@ -453,12 +448,14 @@ model.maximize(x*2 + y*2 + z*3)
 solver = ORTools::CpSolver.new
 status = solver.solve(model)
 
-if status == :optimal
+# display the solution
+if status == :optimal || status == :feasible
   puts "Maximum of objective function: #{solver.objective_value}"
-  puts
-  puts "x value: #{solver.value(x)}"
-  puts "y value: #{solver.value(y)}"
-  puts "z value: #{solver.value(z)}"
+  puts "x = #{solver.value(x)}"
+  puts "y = #{solver.value(y)}"
+  puts "z = #{solver.value(z)}"
+else
+  puts "No solution found."
 end
 ```
 
@@ -613,120 +610,190 @@ if status == :optimal
 end
 ```
 
-### Assignment
+## Assignment
+
+### Solving an Assignment Problem
 
 [Guide](https://developers.google.com/optimization/assignment/assignment_example)
 
 ```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
+costs = [
+  [90, 80, 75, 70],
+  [35, 85, 55, 65],
+  [125, 95, 90, 95],
+  [45, 110, 95, 115],
+  [50, 100, 90, 100]
+]
+num_workers = costs.length
+num_tasks = costs[0].length
 
 # create the solver
-assignment = ORTools::LinearSumAssignment.new
+solver = ORTools::Solver.new("CBC")
 
-# 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
+# create the variables
+x = {}
+num_workers.times do |i|
+  num_tasks.times do |j|
+    x[[i, j]] = solver.int_var(0, 1, "")
   end
 end
 
+# create the constraints
+# each worker is assigned to at most 1 task
+num_workers.times do |i|
+  solver.add(num_tasks.times.sum { |j| x[[i, j]] } <= 1)
+end
+
+# each task is assigned to exactly one worker
+num_tasks.times do |j|
+  solver.add(num_workers.times.sum { |i| x[[i, j]] } == 1)
+end
+
+# create the objective function
+objective_terms = []
+num_workers.times do |i|
+  num_tasks.times do |j|
+    objective_terms << (costs[i][j] * x[[i, j]])
+  end
+end
+solver.minimize(objective_terms.sum)
+
 # 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)
-    ]
+status = solver.solve
+
+# print the solution
+if status == :optimal || status == :feasible
+  puts "Total cost = #{solver.objective.value}"
+  num_workers.times do |i|
+    num_tasks.times do |j|
+      # test if x[i,j] is 1 (with tolerance for floating point arithmetic)
+      if x[[i, j]].solution_value > 0.5
+        puts "Worker #{i} assigned to task #{j}. Cost = #{costs[i][j]}"
+      end
+    end
   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."
+else
+  puts "No solution found."
 end
 ```
 
-### Assignment with Teams
+### Assignment with Teams of Workers
 
-[Guide](https://developers.google.com/optimization/assignment/assignment_teams)
+[Guide](https://developers.google.com/optimization/assignment/assignment_teams#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]]
+costs = [
+  [90, 76, 75, 70],
+  [35, 85, 55, 65],
+  [125, 95, 90, 105],
+  [45, 110, 95, 115],
+  [60, 105, 80, 75],
+  [45, 65, 110, 95]
+]
+num_workers = costs.length
+num_tasks = costs[1].length
 
 team1 = [0, 2, 4]
 team2 = [1, 3, 5]
 team_max = 2
 
+# create the solver
+solver = ORTools::Solver.new("CBC")
+
 # 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
+# add the constraints
+# each worker is assigned at most 1 task
 num_workers.times do |i|
-  solver.add(solver.sum(num_tasks.times.map { |j| x[[i, j]] }) <= 1)
+  solver.add(num_tasks.times.sum { |j| x[[i, j]] } <= 1)
 end
 
+# each task is assigned to exactly one worker
 num_tasks.times do |j|
-  solver.add(solver.sum(num_workers.times.map { |i| x[[i, j]] }) == 1)
+  solver.add(num_workers.times.sum { |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)
+# each team takes at most two tasks
+solver.add(team1.flat_map { |i| num_tasks.times.map { |j| x[[i, j]] } }.sum <= team_max)
+solver.add(team2.flat_map { |i| num_tasks.times.map { |j| x[[i, j]] } }.sum <= team_max)
+
+# create the objective
+solver.minimize(
+  num_workers.times.flat_map { |i| num_tasks.times.map { |j| x[[i, j]] * costs[i][j] } }.sum
+)
 
 # invoke the solver
-sol = solver.solve
+status = 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]
-      ]
+# display the results
+if status == :optimal || status == :feasible
+  puts "Total cost = #{solver.objective.value}"
+  num_workers.times do |worker|
+    num_tasks.times do |task|
+      if x[[worker, task]].solution_value > 0.5
+        puts "Worker #{worker} assigned to task #{task}. Cost = #{costs[worker][task]}"
+      end
     end
   end
+else
+  puts "No solution found."
 end
+```
 
-puts
-puts "Time = #{solver.wall_time} milliseconds"
+### Linear Sum Assignment Solver
+
+[Guide](https://developers.google.com/optimization/assignment/linear_assignment)
+
+```ruby
+# create the data
+costs = [
+  [90, 76, 75, 70],
+  [35, 85, 55, 65],
+  [125, 95, 90, 105],
+  [45, 110, 95, 115],
+]
+num_workers = costs.length
+num_tasks = costs[0].length
+
+# create the solver
+assignment = ORTools::LinearSumAssignment.new
+
+# add the constraints
+num_workers.times do |worker|
+  num_tasks.times do |task|
+    if costs[worker][task]
+      assignment.add_arc_with_cost(worker, task, costs[worker][task])
+    end
+  end
+end
+
+# invoke the solver
+status = assignment.solve
+
+# display the results
+case status
+when :optimal
+  puts "Total cost = #{assignment.optimal_cost}"
+  assignment.num_nodes.times do |i|
+    puts "Worker #{i} assigned to task #{assignment.right_mate(i)}. Cost = #{assignment.assignment_cost(i)}"
+  end
+when :infeasible
+  puts "No assignment is possible."
+when :possible_overflow
+  puts "Some input costs are too large and may cause an integer overflow."
+end
 ```
 
+## Routing
+
 ### Traveling Salesperson Problem (TSP)
 
 [Guide](https://developers.google.com/optimization/routing/tsp.html)
@@ -1376,6 +1443,8 @@ routing.solve(
 )
 ```
 
+## Bin Packing
+
 ### The Knapsack Problem
 
 [Guide](https://developers.google.com/optimization/bin/knapsack)
@@ -1425,53 +1494,40 @@ puts "Packed weights: #{packed_weights}"
 ```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]
-data[:weights] = weights
-data[:values] = values
-data[:items] = (0...weights.length).to_a
-data[:num_items] = weights.length
-num_bins = 5
-data[:bins] = (0...num_bins).to_a
+data[:weights] = [48, 30, 42, 36, 36, 48, 42, 42, 36, 24, 30, 30, 42, 36, 36]
+data[:values] = [10, 30, 25, 50, 35, 30, 15, 40, 30, 35, 45, 10, 20, 30, 25]
+data[:num_items] = data[:weights].length
+data[:all_items] = data[:num_items].times.to_a
 data[:bin_capacities] = [100, 100, 100, 100, 100]
+data[:num_bins] = data[:bin_capacities].length
+data[:all_bins] = data[:num_bins].times.to_a
 
 # declare the solver
-solver = ORTools::Solver.new("simple_mip_program", :cbc)
+solver = ORTools::Solver.new("CBC")
 
 # 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])
+data[:all_items].each do |i|
+  data[:all_bins].each do |b|
+    x[[i, b]] = solver.bool_var("x_#{i}_#{b}")
   end
 end
 
-# 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|
-    sum += x[[i, j]]
-  end
-  solver.add(sum <= 1.0)
+# each item is assigned to at most one bin
+data[:all_items].each do |i|
+  solver.add(data[:all_bins].sum { |b| x[[i, b]] } <= 1)
 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|
-    weight += x[[i, j]] * data[:weights][i]
-  end
-  solver.add(weight <= data[:bin_capacities][j])
+data[:all_bins].each do |b|
+  solver.add(data[:all_items].sum { |i| x[[i, b]] * data[:weights][i] } <= data[:bin_capacities][b])
 end
 
-# define the objective
+# maximize total value of packed items
 objective = solver.objective
-
-data[:items].each do |i|
-  data[:bins].each do |j|
-    objective.set_coefficient(x[[i, j]], data[:values][i])
+data[:all_items].each do |i|
+  data[:all_bins].each do |b|
+    objective.set_coefficient(x[[i, b]], data[:values][i])
   end
 end
 objective.set_maximization
@@ -1482,12 +1538,12 @@ status = solver.solve
 if status == :optimal
   puts "Total packed value: #{objective.value}"
   total_weight = 0
-  data[:bins].each do |j|
+  data[:all_bins].each do |b|
     bin_weight = 0
     bin_value = 0
-    puts "Bin  #{j}\n\n"
-    data[:items].each do |i|
-      if x[[i, j]].solution_value > 0
+    puts "Bin #{b}\n\n"
+    data[:all_items].each do |i|
+      if x[[i, b]].solution_value > 0
         puts "Item #{i} - weight: #{data[:weights][i]}  value: #{data[:values][i]}"
         bin_weight += data[:weights][i]
         bin_value += data[:values][i]
@@ -1518,7 +1574,7 @@ data[:bins] = data[:items]
 data[:bin_capacity] = 100
 
 # create the mip solver with the CBC backend
-solver = ORTools::Solver.new("simple_mip_program", :cbc)
+solver = ORTools::Solver.new("CBC")
 
 # variables
 # x[i, j] = 1 if item i is packed in bin j
@@ -1538,17 +1594,17 @@ end
 # 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)
+  solver.add(data[:bins].sum { |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] })
+  sum = data[:items].sum { |i| x[[i, j]] * data[:weights][i] }
   solver.add(sum <= y[j] * data[:bin_capacity])
 end
 
 # objective: minimize the number of bins used
-solver.minimize(solver.sum(data[:bins].map { |j| y[j] }))
+solver.minimize(data[:bins].sum { |j| y[j] })
 
 # call the solver and print the solution
 if status == :optimal
@@ -1580,6 +1636,8 @@ else
 end
 ```
 
+## Network Flows
+
 ### Maximum Flows
 
 [Guide](https://developers.google.com/optimization/flow/maxflow)
@@ -1664,7 +1722,7 @@ end
 
 ### Assignment as a Min Cost Flow Problem
 
-[Guide](https://developers.google.com/optimization/assignment/assignment_min_cost_flow)
+[Guide](https://developers.google.com/optimization/flow/assignment_min_cost_flow)
 
 ```ruby
 # create the solver
@@ -1711,6 +1769,8 @@ else
 end
 ```
 
+## Scheduling
+
 ### Employee Scheduling
 
 [Guide](https://developers.google.com/optimization/scheduling/employee_scheduling)
@@ -1915,6 +1975,8 @@ puts "Optimal Schedule Length: %i" % solver.objective_value
 puts output
 ```
 
+## Other Examples
+
 ### Sudoku
 
 [Example](https://github.com/google/or-tools/blob/stable/examples/python/sudoku_sat.py)
@@ -2172,7 +2234,7 @@ possible_tables = []
   possible_tables += guests.combination(i).to_a
 end
 
-solver = ORTools::Solver.new("Wedding Seating Model", :cbc)
+solver = ORTools::Solver.new("CBC")
 
 # create a binary variable to state that a table setting is used
 x = {}
@@ -2180,15 +2242,15 @@ 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) }))
+solver.minimize(possible_tables.sum { |table| x[table] * happiness(table) })
 
 # specify the maximum number of tables
-solver.add(solver.sum(x.values) <= max_tables)
+solver.add(x.values.sum <= 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)
+  solver.add(tables_with_guest.sum { |table| x[table] } == 1)
 end
 
 status = solver.solve

data/ext/or-tools/ext.cpp

@@ -1,7 +1,11 @@
 #include <ortools/base/version.h>
+#include <ortools/init/init.h>
 
 #include "ext.h"
 
+using operations_research::CppBridge;
+using operations_research::CppFlags;
+
 void init_assignment(Rice::Module& m);
 void init_bin_packing(Rice::Module& m);
 void init_constraint(Rice::Module& m);
@@ -14,6 +18,7 @@ void Init_ext()
 {
   auto m = Rice::define_module("ORTools");
 
+  // TODO use operations_research::OrToolsVersionString() in 0.8.0
   m.define_singleton_function(
     "lib_version",
     []() {
@@ -27,4 +32,11 @@ void Init_ext()
   init_linear(m);
   init_network_flows(m);
   init_routing(m);
+
+  // fix logging warning
+  CppBridge::InitLogging("");
+  CppFlags flags = CppFlags();
+  flags.logtostderr = true;
+  flags.log_prefix = false;
+  CppBridge::SetFlags(flags);
 }

data/ext/or-tools/extconf.rb

@@ -23,8 +23,9 @@ else
   rpath = "'#{rpath_prefix}/../../tmp/or-tools/lib'"
 end
 
+# find_header and find_library first check without adding path
+# which can cause them to find system library
 $INCFLAGS << " -I#{inc}"
-
 $LDFLAGS.prepend("-Wl,-rpath,#{rpath} -L#{lib} ")
 raise "OR-Tools not found" unless have_library("ortools")
 

data/ext/or-tools/linear.cpp

@@ -47,7 +47,7 @@ namespace Rice::detail
 void init_linear(Rice::Module& m) {
   Rice::define_class_under<LinearRange>(m, "LinearRange");
 
-  // TODO remove in 0.7.0
+  // TODO remove in 0.8.0
   auto rb_cLinearExpr = Rice::define_class_under<LinearExpr>(m, "LinearExpr");
   rb_cLinearExpr.define_constructor(Rice::Constructor<LinearExpr>());
 
@@ -60,12 +60,29 @@ void init_linear(Rice::Module& m) {
 
   Rice::define_class_under<MPObjective>(m, "MPObjective")
     .define_method("value", &MPObjective::Value)
+    .define_method("clear", &MPObjective::Clear)
     .define_method("set_coefficient", &MPObjective::SetCoefficient)
+    .define_method("set_offset", &MPObjective::SetOffset)
     .define_method("set_maximization", &MPObjective::SetMaximization)
     .define_method("set_minimization", &MPObjective::SetMinimization);
 
   Rice::define_class_under<MPSolver>(m, "Solver")
     .define_constructor(Rice::Constructor<MPSolver, std::string, MPSolver::OptimizationProblemType>())
+    .define_singleton_function(
+      "_create",
+      [](const std::string& solver_id) {
+        std::unique_ptr<MPSolver> solver(MPSolver::CreateSolver(solver_id));
+        if (!solver) {
+          throw std::runtime_error("Unrecognized solver type");
+        }
+        return solver;
+      })
+    .define_method(
+      "time_limit=",
+      [](MPSolver& self, double time_limit) {
+        // use milliseconds to match Python
+        self.SetTimeLimit(absl::Milliseconds(time_limit));
+      })
     .define_method(
       "infinity",
       [](MPSolver& self) {
@@ -81,6 +98,8 @@ void init_linear(Rice::Module& m) {
     .define_method("num_variables", &MPSolver::NumVariables)
     .define_method("num_constraints", &MPSolver::NumConstraints)
     .define_method("wall_time", &MPSolver::wall_time)
+    .define_method("enable_output", &MPSolver::EnableOutput)
+    .define_method("suppress_output", &MPSolver::SuppressOutput)
     .define_method("iterations", &MPSolver::iterations)
     .define_method("nodes", &MPSolver::nodes)
     .define_method("objective", &MPSolver::MutableObjective)

data/ext/or-tools/routing.cpp

@@ -9,6 +9,7 @@ using operations_research::DefaultRoutingSearchParameters;
 using operations_research::FirstSolutionStrategy;
 using operations_research::LocalSearchMetaheuristic;
 using operations_research::RoutingDimension;
+using operations_research::RoutingDisjunctionIndex;
 using operations_research::RoutingIndexManager;
 using operations_research::RoutingModel;
 using operations_research::RoutingModelParameters;
@@ -55,6 +56,19 @@ namespace Rice::detail
   };
 }
 
+namespace Rice::detail
+{
+  template<class T, class U>
+  class To_Ruby<std::pair<T, U>>
+  {
+  public:
+    VALUE convert(std::pair<T, U> const & x)
+    {
+      return rb_ary_new3(2, To_Ruby<T>().convert(x.first), To_Ruby<U>().convert(x.second));
+    }
+  };
+}
+
 void init_routing(Rice::Module& m) {
   auto rb_cRoutingSearchParameters = Rice::define_class_under<RoutingSearchParameters>(m, "RoutingSearchParameters");
   auto rb_cIntVar = Rice::define_class_under<operations_research::IntVar>(m, "IntVar");
@@ -198,8 +212,28 @@ void init_routing(Rice::Module& m) {
     .define_method("old_end_max", &operations_research::IntervalVar::OldEndMax);
 
   Rice::define_class_under<RoutingDimension>(m, "RoutingDimension")
+    .define_method("transit_value", &RoutingDimension::GetTransitValue)
+    // TODO GetTransitValueFromClass
+    .define_method("cumul_var", &RoutingDimension::CumulVar)
+    .define_method("transit_var", &RoutingDimension::TransitVar)
+    .define_method("fixed_transit_var", &RoutingDimension::FixedTransitVar)
+    .define_method("slack_var", &RoutingDimension::SlackVar)
+    .define_method("set_span_upper_bound_for_vehicle", &RoutingDimension::SetSpanUpperBoundForVehicle)
+    .define_method("set_span_cost_coefficient_for_vehicle", &RoutingDimension::SetSpanCostCoefficientForVehicle)
+    .define_method("set_span_cost_coefficient_for_all_vehicles", &RoutingDimension::SetSpanCostCoefficientForAllVehicles)
+    .define_method("set_global_span_cost_coefficient", &RoutingDimension::SetGlobalSpanCostCoefficient)
+    // alias
     .define_method("global_span_cost_coefficient=", &RoutingDimension::SetGlobalSpanCostCoefficient)
-    .define_method("cumul_var", &RoutingDimension::CumulVar);
+    .define_method("set_cumul_var_soft_upper_bound", &RoutingDimension::SetCumulVarSoftUpperBound)
+    .define_method("cumul_var_soft_upper_bound?", &RoutingDimension::HasCumulVarSoftUpperBound)
+    .define_method("cumul_var_soft_upper_bound", &RoutingDimension::GetCumulVarSoftUpperBound)
+    .define_method("cumul_var_soft_upper_bound_coefficient", &RoutingDimension::GetCumulVarSoftUpperBoundCoefficient)
+    .define_method("set_cumul_var_soft_lower_bound", &RoutingDimension::SetCumulVarSoftLowerBound)
+    .define_method("cumul_var_soft_lower_bound?", &RoutingDimension::HasCumulVarSoftLowerBound)
+    .define_method("cumul_var_soft_lower_bound", &RoutingDimension::GetCumulVarSoftLowerBound)
+    .define_method("cumul_var_soft_lower_bound_coefficient", &RoutingDimension::GetCumulVarSoftLowerBoundCoefficient);
+
+  Rice::define_class_under<RoutingDisjunctionIndex>(m, "RoutingDisjunctionIndex");
 
   Rice::define_class_under<operations_research::Constraint>(m, "Constraint")
     .define_method("post", &operations_research::Constraint::Post)
@@ -264,27 +298,103 @@ void init_routing(Rice::Module& m) {
 
   Rice::define_class_under<RoutingModel>(m, "RoutingModel")
     .define_constructor(Rice::Constructor<RoutingModel, RoutingIndexManager, RoutingModelParameters>(), Rice::Arg("index_manager"), Rice::Arg("parameters") = operations_research::DefaultRoutingModelParameters())
+    .define_method("register_unary_transit_vector", &RoutingModel::RegisterUnaryTransitVector)
     .define_method(
-      "register_transit_callback",
+      "register_unary_transit_callback",
       [](RoutingModel& self, Object callback) {
-        return self.RegisterTransitCallback(
-          [callback](int64_t from_index, int64_t to_index) -> int64_t {
-            return Rice::detail::From_Ruby<int64_t>().convert(callback.call("call", from_index, to_index));
+        return self.RegisterUnaryTransitCallback(
+          [callback](int64_t from_index) -> int64_t {
+            return Rice::detail::From_Ruby<int64_t>().convert(callback.call("call", from_index));
           }
         );
       })
+    .define_method("register_transit_matrix", &RoutingModel::RegisterTransitMatrix)
     .define_method(
-      "register_unary_transit_callback",
+      "register_transit_callback",
       [](RoutingModel& self, Object callback) {
-        return self.RegisterUnaryTransitCallback(
-          [callback](int64_t from_index) -> int64_t {
-            return Rice::detail::From_Ruby<int64_t>().convert(callback.call("call", from_index));
+        return self.RegisterTransitCallback(
+          [callback](int64_t from_index, int64_t to_index) -> int64_t {
+            return Rice::detail::From_Ruby<int64_t>().convert(callback.call("call", from_index, to_index));
           }
         );
       })
+    .define_method("add_dimension", &RoutingModel::AddDimension)
+    .define_method("add_dimension_with_vehicle_transits", &RoutingModel::AddDimensionWithVehicleTransits)
+    .define_method("add_dimension_with_vehicle_capacity", &RoutingModel::AddDimensionWithVehicleCapacity)
+    .define_method("add_dimension_with_vehicle_transit_and_capacity", &RoutingModel::AddDimensionWithVehicleTransitAndCapacity)
+    .define_method("add_constant_dimension_with_slack", &RoutingModel::AddConstantDimensionWithSlack)
+    .define_method("add_constant_dimension", &RoutingModel::AddConstantDimension)
+    .define_method("add_vector_dimension", &RoutingModel::AddVectorDimension)
+    .define_method("add_matrix_dimension", &RoutingModel::AddMatrixDimension)
+    // TODO AddDimensionDependentDimensionWithVehicleCapacity
+    // .define_method("make_path_spans_and_total_slacks", &RoutingModel::MakePathSpansAndTotalSlacks)
+    .define_method("all_dimension_names", &RoutingModel::GetAllDimensionNames)
+    // .define_method("dimensions", &RoutingModel::GetDimensions)
+    // .define_method("dimensions_with_soft_or_span_costs", &RoutingModel::GetDimensionsWithSoftOrSpanCosts)
+    .define_method("dimension?", &RoutingModel::HasDimension)
+    // .define_method("dimension_or_die", &RoutingModel::GetDimensionOrDie)
+    .define_method("mutable_dimension", &RoutingModel::GetMutableDimension)
+    .define_method("set_primary_constrained_dimension", &RoutingModel::SetPrimaryConstrainedDimension)
+    .define_method("primary_constrained_dimension", &RoutingModel::GetPrimaryConstrainedDimension)
+    .define_method("add_resource_group", &RoutingModel::AddResourceGroup)
+    .define_method("dimension_resource_group_indices", &RoutingModel::GetDimensionResourceGroupIndices)
+    .define_method("dimension_resource_group_index", &RoutingModel::GetDimensionResourceGroupIndex)
+    .define_method("add_disjunction", &RoutingModel::AddDisjunction, Rice::Arg("indices"), Rice::Arg("penalty"), Rice::Arg("max_cardinality") = (int64_t)1)
+    .define_method("disjunction_indices", &RoutingModel::GetDisjunctionIndices)
+    .define_method("disjunction_penalty", &RoutingModel::GetDisjunctionPenalty)
+    .define_method("disjunction_max_cardinality", &RoutingModel::GetDisjunctionMaxCardinality)
+    .define_method("number_of_disjunctions", &RoutingModel::GetNumberOfDisjunctions)
+    .define_method("mandatory_disjunctions?", &RoutingModel::HasMandatoryDisjunctions)
+    .define_method("max_cardinality_constrained_disjunctions?", &RoutingModel::HasMaxCardinalityConstrainedDisjunctions)
+    .define_method("perfect_binary_disjunctions", &RoutingModel::GetPerfectBinaryDisjunctions)
+    .define_method("ignore_disjunctions_already_forced_to_zero", &RoutingModel::IgnoreDisjunctionsAlreadyForcedToZero)
+    .define_method("add_soft_same_vehicle_constraint", &RoutingModel::AddSoftSameVehicleConstraint)
+    .define_method("set_allowed_vehicles_for_index", &RoutingModel::SetAllowedVehiclesForIndex)
+    .define_method("vehicle_allowed_for_index?", &RoutingModel::IsVehicleAllowedForIndex)
+    .define_method("add_pickup_and_delivery", &RoutingModel::AddPickupAndDelivery)
+    .define_method("add_pickup_and_delivery_sets", &RoutingModel::AddPickupAndDeliverySets)
+    .define_method("pickup_index_pairs", &RoutingModel::GetPickupIndexPairs)
+    .define_method("delivery_index_pairs", &RoutingModel::GetDeliveryIndexPairs)
+    // TODO SetPickupAndDeliveryPolicyOfAllVehicles
+    // TODO SetPickupAndDeliveryPolicyOfVehicle
+    // TODO GetPickupAndDeliveryPolicyOfVehicle
+    .define_method("num_of_singleton_nodes", &RoutingModel::GetNumOfSingletonNodes)
+    .define_method("unperformed_penalty", &RoutingModel::UnperformedPenalty)
+    .define_method("unperformed_penalty_or_value", &RoutingModel::UnperformedPenaltyOrValue)
     .define_method("depot", &RoutingModel::GetDepot)
-    .define_method("size", &RoutingModel::Size)
-    .define_method("status", [](RoutingModel& self) {
+    .define_method("set_maximum_number_of_active_vehicles", &RoutingModel::SetMaximumNumberOfActiveVehicles)
+    .define_method("maximum_number_of_active_vehicles", &RoutingModel::GetMaximumNumberOfActiveVehicles)
+    .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("set_amortized_cost_factors_of_all_vehicles", &RoutingModel::SetAmortizedCostFactorsOfAllVehicles)
+    .define_method("set_amortized_cost_factors_of_vehicle", &RoutingModel::SetAmortizedCostFactorsOfVehicle)
+    .define_method("amortized_linear_cost_factor_of_vehicles", &RoutingModel::GetAmortizedLinearCostFactorOfVehicles)
+    .define_method("amortized_quadratic_cost_factor_of_vehicles", &RoutingModel::GetAmortizedQuadraticCostFactorOfVehicles)
+    .define_method("set_vehicle_used_when_empty", &RoutingModel::SetVehicleUsedWhenEmpty)
+    .define_method("vehicle_used_when_empty?", &RoutingModel::IsVehicleUsedWhenEmpty)
+    .define_method("add_variable_minimized_by_finalizer", &RoutingModel::AddVariableMinimizedByFinalizer)
+    .define_method("add_variable_maximized_by_finalizer", &RoutingModel::AddVariableMaximizedByFinalizer)
+    .define_method("add_weighted_variable_minimized_by_finalizer", &RoutingModel::AddWeightedVariableMinimizedByFinalizer)
+    .define_method("add_weighted_variable_maximized_by_finalizer", &RoutingModel::AddWeightedVariableMaximizedByFinalizer)
+    .define_method("add_variable_target_to_finalizer", &RoutingModel::AddVariableTargetToFinalizer)
+    .define_method("add_weighted_variable_target_to_finalizer", &RoutingModel::AddWeightedVariableTargetToFinalizer)
+    .define_method("close_model", &RoutingModel::CloseModel)
+    .define_method(
+      "solve",
+      [](RoutingModel& self) {
+        return self.Solve();
+      })
+    .define_method(
+      "solve_with_parameters",
+      [](RoutingModel& self, const RoutingSearchParameters& search_parameters) {
+        return self.SolveWithParameters(search_parameters);
+      })
+    .define_method("compute_lower_bound", &RoutingModel::ComputeLowerBound)
+    .define_method("status",
+      [](RoutingModel& self) {
         auto status = self.status();
 
         if (status == RoutingModel::ROUTING_NOT_SOLVED) {
@@ -301,30 +411,22 @@ void init_routing(Rice::Module& m) {
           throw std::runtime_error("Unknown solver status");
         }
       })
-    .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_t slack_max, std::vector<int64_t> vehicle_capacities, bool fix_start_cumul_to_zero, const std::string& name) {
-        self.AddDimensionWithVehicleCapacity(evaluator_index, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name);
-      })
-    .define_method(
-      "add_dimension_with_vehicle_transits",
-      [](RoutingModel& self, std::vector<int> evaluator_indices, int64_t slack_max, int64_t capacity, bool fix_start_cumul_to_zero, const std::string& name) {
-        self.AddDimensionWithVehicleTransits(evaluator_indices, slack_max, capacity, fix_start_cumul_to_zero, name);
-      })
-    .define_method(
-      "add_disjunction",
-      [](RoutingModel& self, std::vector<int64_t> indices, int64_t penalty) {
-        self.AddDisjunction(indices, penalty);
-      })
-    .define_method("add_pickup_and_delivery", &RoutingModel::AddPickupAndDelivery)
-    .define_method("solver", &RoutingModel::solver)
+    .define_method("apply_locks", &RoutingModel::ApplyLocks)
+    .define_method("apply_locks_to_all_vehicles", &RoutingModel::ApplyLocksToAllVehicles)
+    .define_method("pre_assignment", &RoutingModel::PreAssignment)
+    .define_method("mutable_pre_assignment", &RoutingModel::MutablePreAssignment)
+    .define_method("write_assignment", &RoutingModel::WriteAssignment)
+    .define_method("read_assignment", &RoutingModel::ReadAssignment)
+    .define_method("restore_assignment", &RoutingModel::RestoreAssignment)
+    .define_method("read_assignment_from_routes", &RoutingModel::ReadAssignmentFromRoutes)
+    .define_method("routes_to_assignment", &RoutingModel::RoutesToAssignment)
+    .define_method("assignment_to_routes", &RoutingModel::AssignmentToRoutes)
+    .define_method("compact_assignment", &RoutingModel::CompactAssignment)
+    .define_method("compact_and_check_assignment", &RoutingModel::CompactAndCheckAssignment)
+    .define_method("add_to_assignment", &RoutingModel::AddToAssignment)
+    .define_method("add_interval_to_assignment", &RoutingModel::AddIntervalToAssignment)
+    // TODO PackCumulsOfOptimizerDimensionsFromAssignment
+    // TODO AddLocalSearchFilter
     .define_method("start", &RoutingModel::Start)
     .define_method("end", &RoutingModel::End)
     .define_method("start?", &RoutingModel::IsStart)
@@ -333,12 +435,23 @@ void init_routing(Rice::Module& m) {
     .define_method("next", &RoutingModel::Next)
     .define_method("vehicle_used?", &RoutingModel::IsVehicleUsed)
     .define_method("next_var", &RoutingModel::NextVar)
+    .define_method("active_var", &RoutingModel::ActiveVar)
+    .define_method("active_vehicle_var", &RoutingModel::ActiveVehicleVar)
+    .define_method("vehicle_route_considered_var", &RoutingModel::VehicleRouteConsideredVar)
+    .define_method("vehicle_var", &RoutingModel::VehicleVar)
+    .define_method("resource_var", &RoutingModel::ResourceVar)
+    .define_method("cost_var", &RoutingModel::CostVar)
     .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) {
-        return self.SolveWithParameters(search_parameters);
-      });
+    .define_method("costs_are_homogeneous_across_vehicles?", &RoutingModel::CostsAreHomogeneousAcrossVehicles)
+    .define_method("homogeneous_cost", &RoutingModel::GetHomogeneousCost)
+    .define_method("arc_cost_for_first_solution", &RoutingModel::GetArcCostForFirstSolution)
+    .define_method("cost_classes_count", &RoutingModel::GetCostClassesCount)
+    .define_method("non_zero_cost_classes_count", &RoutingModel::GetNonZeroCostClassesCount)
+    .define_method("vehicle_classes_count", &RoutingModel::GetVehicleClassesCount)
+    .define_method("arc_is_more_constrained_than_arc?", &RoutingModel::ArcIsMoreConstrainedThanArc)
+    .define_method("solver", &RoutingModel::solver)
+    .define_method("nodes", &RoutingModel::nodes)
+    .define_method("vehicles", &RoutingModel::vehicles)
+    .define_method("size", &RoutingModel::Size)
+    .define_method("matching_model?", &RoutingModel::IsMatchingModel);
 }

data/ext/or-tools/vendor.rb

@@ -142,12 +142,11 @@ Dir.mktmpdir do |extract_path|
 
   # shared library
   FileUtils.mkdir(File.join(path, "lib"))
-  Dir.glob("lib/libortools.{dylib,so.9}", base: extract_path) do |file|
-    FileUtils.cp(File.join(extract_path, file), File.join(path, file))
-  end
-  so_path = File.join(path, "lib/libortools.so.9")
-  if File.exist?(so_path)
-    File.symlink(so_path, File.join(path, "lib/libortools.so"))
+  Dir.glob("lib/libortools.{9.dylib,so.9}", base: extract_path) do |file|
+    so_path = File.join(path, file)
+    FileUtils.cp(File.join(extract_path, file), so_path)
+    ext = file.end_with?(".dylib") ? "dylib" : "so"
+    File.symlink(so_path, File.join(path, "lib/libortools.#{ext}"))
   end
 end
 

data/lib/or_tools/cp_solver.rb

@@ -12,6 +12,12 @@ module ORTools
     end
 
     def value(var)
+      # could also check solution_size == 0
+      unless [:feasible, :optimal].include?(@response.status)
+        # could return nil, but raise error like Python library
+        raise Error, "No solution found"
+      end
+
       if var.is_a?(BoolVar)
         _solution_boolean_value(@response, var)
       else

data/lib/or_tools/linear_expr.rb

@@ -27,7 +27,11 @@ module ORTools
     end
 
     def *(other)
-      ProductCst.new(self, other)
+      if is_a?(Constant)
+        ProductCst.new(other, @val)
+      else
+        ProductCst.new(self, other)
+      end
     end
 
     def /(cst)
@@ -69,5 +73,13 @@ module ORTools
     def inspect
       "#<#{self.class.name} #{to_s}>"
     end
+
+    def coerce(other)
+      if other.is_a?(Numeric)
+        [Constant.new(other), self]
+      else
+        raise TypeError, "#{self.class} can't be coerced into #{other.class}"
+      end
+    end
   end
 end

data/lib/or_tools/mp_variable.rb

@@ -1,5 +1,5 @@
 module ORTools
-  # TODO change to VariableExpr in 0.7.0
+  # TODO change to VariableExpr in 0.8.0
   class MPVariable < LinearExpr
     def add_self_to_coeff_map_or_stack(coeffs, multiplier, stack)
       coeffs[self] += multiplier

data/lib/or_tools/solver.rb

@@ -9,17 +9,37 @@ module ORTools
     end
 
     def maximize(expr)
-      expr.coeffs.each do |v, c|
-        objective.set_coefficient(v, c)
-      end
+      set_objective(expr)
       objective.set_maximization
     end
 
     def minimize(expr)
-      expr.coeffs.each do |v, c|
+      set_objective(expr)
+      objective.set_minimization
+    end
+
+    private
+
+    def set_objective(expr)
+      objective.clear
+      coeffs = expr.coeffs
+      offset = coeffs.delete(OFFSET_KEY)
+      objective.set_offset(offset) if offset
+      coeffs.each do |v, c|
         objective.set_coefficient(v, c)
       end
-      objective.set_minimization
     end
+
+    # hack to work with Rice constructor
+    m = Module.new do
+      def new(solver_id, *args)
+        if args.empty?
+          _create(solver_id)
+        else
+          super
+        end
+      end
+    end
+    singleton_class.prepend(m)
   end
 end

data/lib/or_tools/tsp.rb

@@ -22,13 +22,7 @@ module ORTools
       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)
+      transit_callback_index = routing.register_transit_matrix(distance_matrix)
       routing.set_arc_cost_evaluator_of_all_vehicles(transit_callback_index)
       assignment = routing.solve(first_solution_strategy: :path_cheapest_arc)
 

data/lib/or_tools/version.rb

@@ -1,3 +1,3 @@
 module ORTools
-  VERSION = "0.7.0"
+  VERSION = "0.7.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: or-tools
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.7.3
 platform: ruby
 authors:
 - Andrew Kane
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-03-23 00:00:00.000000000 Z
+date: 2022-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rice
@@ -75,7 +75,7 @@ files:
 - lib/or_tools/version.rb
 homepage: https://github.com/ankane/or-tools-ruby
 licenses:
-- MIT
+- Apache-2.0
 metadata: {}
 post_install_message:
 rdoc_options: []