or-tools 0.2.0 → 0.3.4

data/ext/or-tools/ext.cpp

@@ -101,6 +101,14 @@ Object to_ruby<RoutingNodeIndex>(RoutingNodeIndex const &x)
   return to_ruby<int>(x.value());
 }
 
+std::vector<RoutingNodeIndex> nodeIndexVector(Array x) {
+  std::vector<RoutingNodeIndex> res;
+  for (auto const& v : x) {
+    res.push_back(from_ruby<RoutingNodeIndex>(v));
+  }
+  return res;
+}
+
 template<>
 inline
 operations_research::sat::LinearExpr from_ruby<operations_research::sat::LinearExpr>(Object x)
@@ -630,18 +638,24 @@ void Init_ext()
         self.Minimize(expr);
       });
 
+  define_class_under<SatParameters>(rb_mORTools, "SatParameters")
+    .define_constructor(Constructor<SatParameters>())
+    .define_method("max_time_in_seconds=",
+    *[](SatParameters& self, double value) {
+      self.set_max_time_in_seconds(value);
+    });
+
   define_class_under(rb_mORTools, "CpSolver")
     .define_method(
       "_solve_with_observer",
-      *[](Object self, CpModelBuilder& model, Object callback, bool all_solutions) {
+      *[](Object self, CpModelBuilder& model, SatParameters& parameters, Object callback, bool all_solutions) {
         operations_research::sat::Model m;
 
         if (all_solutions) {
           // set parameters for SearchForAllSolutions
-          SatParameters parameters;
           parameters.set_enumerate_all_solutions(true);
-          m.Add(NewSatParameters(parameters));
         }
+        m.Add(NewSatParameters(parameters));
 
         m.Add(NewFeasibleSolutionObserver(
           [callback](const CpSolverResponse& r) {
@@ -654,13 +668,20 @@ void Init_ext()
       })
     .define_method(
       "_solve",
-      *[](Object self, CpModelBuilder& model) {
-        return Solve(model.Build());
+      *[](Object self, CpModelBuilder& model, SatParameters& parameters) {
+        operations_research::sat::Model m;
+        m.Add(NewSatParameters(parameters));
+        return SolveCpModel(model.Build(), &m);
       })
     .define_method(
       "_solution_integer_value",
       *[](Object self, CpSolverResponse& response, operations_research::sat::IntVar& x) {
         return SolutionIntegerValue(response, x);
+      })
+    .define_method(
+      "_solution_boolean_value",
+      *[](Object self, CpSolverResponse& response, operations_research::sat::BoolVar& x) {
+        return SolutionBooleanValue(response, x);
       });
 
   define_class_under<CpSolverResponse>(rb_mORTools, "CpSolverResponse")
@@ -688,13 +709,24 @@ void Init_ext()
           return Symbol("infeasible");
         } else if (status == CpSolverStatus::MODEL_INVALID) {
           return Symbol("model_invalid");
+        } else if (status == CpSolverStatus::UNKNOWN) {
+          return Symbol("unknown");
         } else {
           throw std::runtime_error("Unknown solver status");
         }
       });
 
   define_class_under<RoutingIndexManager>(rb_mORTools, "RoutingIndexManager")
-    .define_constructor(Constructor<RoutingIndexManager, int, int, RoutingNodeIndex>())
+    .define_singleton_method(
+      "_new_depot",
+      *[](int num_nodes, int num_vehicles, RoutingNodeIndex depot) {
+        return RoutingIndexManager(num_nodes, num_vehicles, depot);
+      })
+    .define_singleton_method(
+      "_new_starts_ends",
+      *[](int num_nodes, int num_vehicles, Array starts, Array ends) {
+        return RoutingIndexManager(num_nodes, num_vehicles, nodeIndexVector(starts), nodeIndexVector(ends));
+      })
     .define_method("index_to_node", &RoutingIndexManager::IndexToNode)
     .define_method("node_to_index", &RoutingIndexManager::NodeToIndex);
 
@@ -784,6 +816,23 @@ void Init_ext()
       })
     .define_method("depot", &RoutingModel::GetDepot)
     .define_method("size", &RoutingModel::Size)
+    .define_method("status", *[](RoutingModel& self) {
+        auto status = self.status();
+
+        if (status == RoutingModel::ROUTING_NOT_SOLVED) {
+          return Symbol("not_solved");
+        } else if (status == RoutingModel::ROUTING_SUCCESS) {
+          return Symbol("success");
+        } else if (status == RoutingModel::ROUTING_FAIL) {
+          return Symbol("fail");
+        } else if (status == RoutingModel::ROUTING_FAIL_TIMEOUT) {
+          return Symbol("fail_timeout");
+        } else if (status == RoutingModel::ROUTING_INVALID) {
+          return Symbol("invalid");
+        } else {
+          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)
@@ -800,6 +849,15 @@ void Init_ext()
         }
         self.AddDimensionWithVehicleCapacity(evaluator_index, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name);
       })
+    .define_method(
+      "add_dimension_with_vehicle_transits",
+      *[](RoutingModel& self, Array rb_indices, int64 slack_max, int64 capacity, bool fix_start_cumul_to_zero, const std::string& name) {
+        std::vector<int> evaluator_indices;
+        for (std::size_t i = 0; i < rb_indices.size(); ++i) {
+          evaluator_indices.push_back(from_ruby<int>(rb_indices[i]));
+        }
+        self.AddDimensionWithVehicleTransits(evaluator_indices, slack_max, capacity, fix_start_cumul_to_zero, name);
+      })
     .define_method(
       "add_disjunction",
       *[](RoutingModel& self, Array rb_indices, int64 penalty) {

data/ext/or-tools/vendor.rb

@@ -3,26 +3,29 @@ require "fileutils"
 require "net/http"
 require "tmpdir"
 
-version = "7.6.7691"
+version = "7.8.7959"
 
 if RbConfig::CONFIG["host_os"] =~ /darwin/i
-  filename = "or-tools_MacOsX-10.15.4_v#{version}.tar.gz"
-  checksum = "39e26ba27b4d3a1c194c1478e864cd016d62cf516cd9227a9f23e6143e131572"
+  filename = "or-tools_MacOsX-10.15.6_v#{version}.tar.gz"
+  checksum = "8d1d92105e962fab2fd7bde5843b711334a9f246dc22c51d41281898dbc1f69d"
 else
   os = %x[lsb_release -is].chomp rescue nil
   os_version = %x[lsb_release -rs].chomp rescue nil
-  if os == "Ubuntu" && os_version == "18.04"
+  if os == "Ubuntu" && os_version == "20.04"
+    filename = "or-tools_ubuntu-20.04_v#{version}.tar.gz"
+    checksum = "40018cd573305cec76e12ff87e84d4ec18ce0823f265e4d75625bf3aefdea7c9"
+  elsif os == "Ubuntu" && os_version == "18.04"
     filename = "or-tools_ubuntu-18.04_v#{version}.tar.gz"
-    checksum = "79ef61dfc63b98133ed637f02e837f714a95987424332e511a3a87edd5ce17dc"
+    checksum = "6e53e1a7b82b65b928617b9dce663778c5200de9366ad948948597dc763b1943"
   elsif os == "Ubuntu" && os_version == "16.04"
     filename = "or-tools_ubuntu-16.04_v#{version}.tar.gz"
-    checksum = "a25fc94c0f0d16abf1f6da2a054040c21ef3cbf618a831a15afe21bf14f2d1fb"
+    checksum = "182cd4e2a1d2f29a9a81f2f90cb3e05cf1c0731c1a1e94c471d79a74dc09fff0"
   elsif os == "Debian" && os_version == "10"
     filename = "or-tools_debian-10_v#{version}.tar.gz "
-    checksum = "158c44038aebc42b42b98e8f3733ba83bf230e8a0379803cc48aafbb2f7bdf5a"
+    checksum = "87dd294237095a7fea466c47789802b0a66c664fa1f79e6bbb2cd36323b409ca"
   elsif os == "CentOS" && os_version == "8"
     filename = "or-tools_centos-8_v#{version}.tar.gz"
-    checksum = "a2b800d4e498561e5b1fe95ee1e64c867be496038883f4f7b199499bf71a0eed"
+    checksum = "4e61bf2994fc767da1b4fd073f554c944d2c811609df4bc1afa6a2d876c05bb4"
   else
     # there is a binary download for Windows
     # however, it's compiled with Visual Studio rather than MinGW (which RubyInstaller uses)

data/lib/or-tools.rb

@@ -11,12 +11,19 @@ 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_index_manager"
 require "or_tools/routing_model"
 require "or_tools/sat_linear_expr"
 require "or_tools/sat_int_var"
 require "or_tools/solver"
 require "or_tools/version"
 
+# higher level interfaces
+require "or_tools/basic_scheduler"
+require "or_tools/seating"
+require "or_tools/sudoku"
+require "or_tools/tsp"
+
 module ORTools
   class Error < StandardError; end
 end

data/lib/or_tools/basic_scheduler.rb

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

data/lib/or_tools/cp_solver.rb

@@ -7,22 +7,30 @@ module ORTools
     def_delegators :@response, :objective_value, :num_conflicts, :num_branches, :wall_time
 
     def solve(model)
-      @response = _solve(model)
+      @response = _solve(model, parameters)
       @response.status
     end
 
     def value(var)
-      _solution_integer_value(@response, var)
+      if var.is_a?(BoolVar)
+        _solution_boolean_value(@response, var)
+      else
+        _solution_integer_value(@response, var)
+      end
     end
 
     def solve_with_solution_callback(model, observer)
-      @response = _solve_with_observer(model, observer, false)
+      @response = _solve_with_observer(model, parameters, observer, false)
       @response.status
     end
 
     def search_for_all_solutions(model, observer)
-      @response = _solve_with_observer(model, observer, true)
+      @response = _solve_with_observer(model, parameters, observer, true)
       @response.status
     end
+
+    def parameters
+      @parameters ||= SatParameters.new
+    end
   end
 end

data/lib/or_tools/routing_index_manager.rb

@@ -0,0 +1,11 @@
+module ORTools
+  class RoutingIndexManager
+    def self.new(num_nodes, num_vehicles, starts, ends = nil)
+      if ends
+        _new_starts_ends(num_nodes, num_vehicles, starts, ends)
+      else
+        _new_depot(num_nodes, num_vehicles, starts)
+      end
+    end
+  end
+end

data/lib/or_tools/seating.rb

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

data/lib/or_tools/sudoku.rb

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