or-tools 0.1.3 → 0.3.1

data/ext/or-tools/ext.cpp

@@ -117,7 +117,7 @@ operations_research::sat::LinearExpr from_ruby
       Object o = cvar[0];
       std::string type = ((String) o.call("class").call("name")).str();
       if (type == "ORTools::BoolVar") {
-        expr.AddVar(from_ruby<operations_research::sat::BoolVar>(cvar[0]));
+        expr.AddTerm(from_ruby<operations_research::sat::BoolVar>(cvar[0]), from_ruby<int64>(cvar[1]));
       } else if (type == "Integer") {
         expr.AddConstant(from_ruby<int64>(cvar[0]));
       } else {
@@ -125,7 +125,12 @@ operations_research::sat::LinearExpr from_ruby
       }
     }
   } else {
-    expr = from_ruby<operations_research::sat::IntVar>(x);
+    std::string type = ((String) x.call("class").call("name")).str();
+    if (type == "ORTools::BoolVar") {
+      expr = from_ruby<operations_research::sat::BoolVar>(x);
+    } else {
+      expr = from_ruby<operations_research::sat::IntVar>(x);
+    }
   }
 
   return expr;
@@ -239,6 +244,50 @@ IntVarSpan from_ruby(Object x)
   return IntVarSpan(x);
 }
 
+// need a wrapper class since absl::Span doesn't own
+class IntervalVarSpan {
+  std::vector<operations_research::sat::IntervalVar> vec;
+  public:
+    IntervalVarSpan(Object x) {
+      Array a = Array(x);
+      for (std::size_t i = 0; i < a.size(); ++i) {
+        vec.push_back(from_ruby<operations_research::sat::IntervalVar>(a[i]));
+      }
+    }
+    operator absl::Span<const operations_research::sat::IntervalVar>() {
+      return absl::Span<const operations_research::sat::IntervalVar>(vec);
+    }
+};
+
+template<>
+inline
+IntervalVarSpan from_ruby<IntervalVarSpan>(Object x)
+{
+  return IntervalVarSpan(x);
+}
+
+// need a wrapper class since absl::Span doesn't own
+class BoolVarSpan {
+  std::vector<operations_research::sat::BoolVar> vec;
+  public:
+    BoolVarSpan(Object x) {
+      Array a = Array(x);
+      for (std::size_t i = 0; i < a.size(); ++i) {
+        vec.push_back(from_ruby<operations_research::sat::BoolVar>(a[i]));
+      }
+    }
+    operator absl::Span<const operations_research::sat::BoolVar>() {
+      return absl::Span<const operations_research::sat::BoolVar>(vec);
+    }
+};
+
+template<>
+inline
+BoolVarSpan from_ruby<BoolVarSpan>(Object x)
+{
+  return BoolVarSpan(x);
+}
+
 extern "C"
 void Init_ext()
 {
@@ -338,10 +387,15 @@ void Init_ext()
     .define_method("solution_value", &MPVariable::solution_value)
     .define_method(
       "+",
-      *[](MPVariable& self, MPVariable& other) {
+      *[](MPVariable& self, LinearExpr& other) {
         LinearExpr s(&self);
-        LinearExpr o(&other);
-        return s + o;
+        return s + other;
+      })
+    .define_method(
+      "-",
+      *[](MPVariable& self, LinearExpr& other) {
+        LinearExpr s(&self);
+        return s - other;
       })
     .define_method(
       "*",
@@ -368,6 +422,17 @@ void Init_ext()
         LinearExpr o(&other);
         return self + o;
       })
+    .define_method(
+      "_gte_double",
+      *[](LinearExpr& self, double other) {
+        LinearExpr o(other);
+        return self >= o;
+      })
+    .define_method(
+      "_gte_linear_expr",
+      *[](LinearExpr& self, LinearExpr& other) {
+        return self >= other;
+      })
     .define_method(
       "_lte_double",
       *[](LinearExpr& self, double other) {
@@ -422,6 +487,11 @@ void Init_ext()
     .define_method("iterations", &MPSolver::iterations)
     .define_method("nodes", &MPSolver::nodes)
     .define_method("objective", &MPSolver::MutableObjective)
+    .define_method(
+      "maximize",
+      *[](MPSolver& self, LinearExpr& expr) {
+        return self.MutableObjective()->MaximizeLinearExpr(expr);
+      })
     .define_method(
       "minimize",
       *[](MPSolver& self, LinearExpr& expr) {
@@ -461,13 +531,18 @@ void Init_ext()
         }
       });
 
-  // not to be confused with operations_research::IntVar
   define_class_under<operations_research::sat::IntVar>(rb_mORTools, "SatIntVar")
     .define_method("name", &operations_research::sat::IntVar::Name);
 
+  define_class_under<operations_research::sat::IntervalVar>(rb_mORTools, "SatIntervalVar")
+    .define_method("name", &operations_research::sat::IntervalVar::Name);
+
+  define_class_under<operations_research::sat::Constraint>(rb_mORTools, "SatConstraint");
+
   define_class_under<BoolVar>(rb_mORTools, "BoolVar")
     .define_method("name", &BoolVar::Name)
     .define_method("index", &BoolVar::index)
+    .define_method("not", &BoolVar::Not)
     .define_method(
       "inspect",
       *[](BoolVar& self) {
@@ -488,6 +563,11 @@ void Init_ext()
       *[](CpModelBuilder& self, std::string name) {
         return self.NewBoolVar().WithName(name);
       })
+    .define_method(
+      "new_interval_var",
+      *[](CpModelBuilder& self, operations_research::sat::IntVar start, operations_research::sat::IntVar size, operations_research::sat::IntVar end, std::string name) {
+        return self.NewIntervalVar(start, size, end).WithName(name);
+      })
     .define_method(
       "add_equality",
       *[](CpModelBuilder& self, operations_research::sat::LinearExpr x, operations_research::sat::LinearExpr y) {
@@ -523,6 +603,22 @@ void Init_ext()
       *[](CpModelBuilder& self, IntVarSpan vars) {
         self.AddAllDifferent(vars);
       })
+    .define_method(
+      "add_max_equality",
+      *[](CpModelBuilder& self, operations_research::sat::IntVar target, IntVarSpan vars) {
+        self.AddMaxEquality(target, vars);
+      })
+    .define_method(
+      "add_no_overlap",
+      *[](CpModelBuilder& self, IntervalVarSpan vars) {
+        self.AddNoOverlap(vars);
+      })
+    .define_method(
+      "add_bool_or",
+      *[](CpModelBuilder& self, BoolVarSpan literals) {
+        self.AddBoolOr(literals);
+      })
+    .define_method("add_implication", &CpModelBuilder::AddImplication)
     .define_method(
       "maximize",
       *[](CpModelBuilder& self, operations_research::sat::LinearExpr expr) {
@@ -537,13 +633,15 @@ void Init_ext()
   define_class_under(rb_mORTools, "CpSolver")
     .define_method(
       "_solve_with_observer",
-      *[](Object self, CpModelBuilder& model, Object callback) {
+      *[](Object self, CpModelBuilder& model, Object callback, bool all_solutions) {
         operations_research::sat::Model m;
 
-        // set parameters for SearchForAllSolutions
-        SatParameters parameters;
-        parameters.set_enumerate_all_solutions(true);
-        m.Add(NewSatParameters(parameters));
+        if (all_solutions) {
+          // set parameters for SearchForAllSolutions
+          SatParameters parameters;
+          parameters.set_enumerate_all_solutions(true);
+          m.Add(NewSatParameters(parameters));
+        }
 
         m.Add(NewFeasibleSolutionObserver(
           [callback](const CpSolverResponse& r) {
@@ -563,6 +661,11 @@ void Init_ext()
       "_solution_integer_value",
       *[](Object self, CpSolverResponse& response, operations_research::sat::IntVar& x) {
         return SolutionIntegerValue(response, x);
+      })
+    .define_method(
+      "_solution_boolean_value",
+      *[](Object self, CpSolverResponse& response, operations_research::sat::BoolVar& x) {
+        return SolutionBooleanValue(response, x);
       });
 
   define_class_under<CpSolverResponse>(rb_mORTools, "CpSolverResponse")

data/ext/or-tools/extconf.rb

@@ -1,6 +1,6 @@
 require "mkmf-rice"
 
-abort "Missing stdc++" unless have_library("stdc++")
+raise "Missing stdc++" unless have_library("stdc++")
 
 $CXXFLAGS << " -std=c++11 -DUSE_CBC"
 
@@ -8,73 +8,31 @@ $CXXFLAGS << " -std=c++11 -DUSE_CBC"
 $CXXFLAGS << " -Wno-sign-compare -Wno-shorten-64-to-32 -Wno-ignored-qualifiers"
 
 inc, lib = dir_config("or-tools")
-
-inc ||= "/usr/local/include"
-lib ||= "/usr/local/lib"
+if inc || lib
+  inc ||= "/usr/local/include"
+  lib ||= "/usr/local/lib"
+  rpath = lib
+else
+  # download
+  require_relative "vendor"
+
+  inc = "#{$vendor_path}/include"
+  lib = "#{$vendor_path}/lib"
+
+  # make rpath relative
+  # use double dollar sign and single quotes to escape properly
+  rpath_prefix = RbConfig::CONFIG["host_os"] =~ /darwin/ ? "@loader_path" : "$$ORIGIN"
+  rpath = "'#{rpath_prefix}/../../tmp/or-tools/lib'"
+end
 
 $INCFLAGS << " -I#{inc}"
 
-$LDFLAGS << " -Wl,-rpath,#{lib}"
+$LDFLAGS << " -Wl,-rpath,#{rpath}"
 $LDFLAGS << " -L#{lib}"
-$LDFLAGS << " -lortools"
+raise "OR-Tools not found" unless have_library("ortools")
 
-%w(
-  absl_city
-  absl_time_zone
-  absl_spinlock_wait
-  absl_log_severity
-  absl_failure_signal_handler
-  absl_bad_optional_access
-  absl_hash
-  absl_raw_logging_internal
-  absl_random_internal_pool_urbg
-  absl_base
-  absl_bad_any_cast_impl
-  absl_periodic_sampler
-  absl_random_distributions
-  absl_flags_usage_internal
-  absl_random_seed_sequences
-  absl_throw_delegate
-  absl_flags_handle
-  absl_dynamic_annotations
-  absl_debugging_internal
-  absl_strings
-  absl_flags
-  absl_malloc_internal
-  absl_str_format_internal
-  absl_flags_usage
-  absl_strings_internal
-  absl_flags_program_name
-  absl_flags_registry
-  absl_int128
-  absl_scoped_set_env
-  absl_raw_hash_set
-  absl_random_internal_seed_material
-  absl_symbolize
-  absl_random_internal_randen_slow
-  absl_graphcycles_internal
-  absl_exponential_biased
-  absl_random_internal_randen_hwaes_impl
-  absl_bad_variant_access
-  absl_stacktrace
-  absl_random_internal_randen_hwaes
-  absl_flags_parse
-  absl_random_internal_randen
-  absl_random_internal_distribution_test_util
-  absl_time
-  absl_flags_config
-  absl_synchronization
-  absl_hashtablez_sampler
-  absl_demangle_internal
-  absl_leak_check
-  absl_flags_marshalling
-  absl_leak_check_disable
-  absl_examine_stack
-  absl_flags_internal
-  absl_random_seed_gen_exception
-  absl_civil_time
-).each do |lib|
-  $LDFLAGS << " -l#{lib}"
+Dir["#{lib}/libabsl_*.a"].each do |lib|
+  $LDFLAGS << " #{lib}"
 end
 
 create_makefile("or_tools/ext")

data/ext/or-tools/vendor.rb

@@ -0,0 +1,95 @@
+require "digest"
+require "fileutils"
+require "net/http"
+require "tmpdir"
+
+version = "7.7.7810"
+
+if RbConfig::CONFIG["host_os"] =~ /darwin/i
+  filename = "or-tools_MacOsX-10.15.5_v#{version}.tar.gz"
+  checksum = "764f290f6d916bc366913a37d93e6f83bd7969ad33515ccc1ca390f544d65721"
+else
+  os = %x[lsb_release -is].chomp rescue nil
+  os_version = %x[lsb_release -rs].chomp rescue nil
+  if os == "Ubuntu" && os_version == "18.04"
+    filename = "or-tools_ubuntu-18.04_v#{version}.tar.gz"
+    checksum = "12bdac29144b077b3f9ba602f947e4b9b9ce63ed3df4e325cda1333827edbcf8"
+  elsif os == "Ubuntu" && os_version == "16.04"
+    filename = "or-tools_ubuntu-16.04_v#{version}.tar.gz"
+    checksum = "cc696d342b97aa6cf7c62b6ae2cae95dfc665f2483d147c4117fdba434b13a53"
+  elsif os == "Debian" && os_version == "10"
+    filename = "or-tools_debian-10_v#{version}.tar.gz "
+    checksum = "3dd0299e9ad8d12fe6d186bfd59e63080c8e9f3c6b0489af9900c389cf7e4224"
+  elsif os == "CentOS" && os_version == "8"
+    filename = "or-tools_centos-8_v#{version}.tar.gz"
+    checksum = "1f7d8bce56807c4283374e05024ffac8afd81ff99063217418d02d626cf03088"
+  else
+    # there is a binary download for Windows
+    # however, it's compiled with Visual Studio rather than MinGW (which RubyInstaller uses)
+    raise <<~MSG
+      Binary installation not available for this platform.
+
+      Build the OR-Tools C++ library from source, then run:
+      bundle config build.or-tools --with-or-tools-dir=/path/to/or-tools
+
+    MSG
+  end
+end
+
+short_version = version.split(".").first(2).join(".")
+url = "https://github.com/google/or-tools/releases/download/v#{short_version}/#{filename}"
+
+$stdout.sync = true
+
+def download_file(url, download_path)
+  uri = URI(url)
+  location = nil
+
+  Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
+    request = Net::HTTP::Get.new(uri)
+    http.request(request) do |response|
+      case response
+      when Net::HTTPRedirection
+        location = response["location"]
+      when Net::HTTPSuccess
+        i = 0
+        File.open(download_path, "wb") do |f|
+          response.read_body do |chunk|
+            f.write(chunk)
+
+            # print progress
+            putc "." if i % 50 == 0
+            i += 1
+          end
+        end
+        puts # newline
+      else
+        raise "Bad response"
+      end
+    end
+  end
+
+  # outside of Net::HTTP block to close previous connection
+  download_file(location, download_path) if location
+end
+
+# download
+download_path = "#{Dir.tmpdir}/#{filename}"
+unless File.exist?(download_path)
+  puts "Downloading #{url}..."
+  download_file(url, download_path)
+end
+
+# check integrity - do this regardless of if just downloaded
+download_checksum = Digest::SHA256.file(download_path).hexdigest
+raise "Bad checksum: #{download_checksum}" if download_checksum != checksum
+
+# extract - can't use Gem::Package#extract_tar_gz from RubyGems
+# since it limits filenames to 100 characters (doesn't support UStar format)
+path = File.expand_path("../../tmp/or-tools", __dir__)
+FileUtils.mkdir_p(path)
+tar_args = Gem.win_platform? ? ["--force-local"] : []
+system "tar", "zxf", download_path, "-C", path, "--strip-components=1", *tar_args
+
+# export
+$vendor_path = path

data/lib/or-tools.rb

@@ -4,6 +4,7 @@ require "or_tools/ext"
 # modules
 require "or_tools/comparison"
 require "or_tools/comparison_operators"
+require "or_tools/bool_var"
 require "or_tools/cp_model"
 require "or_tools/cp_solver"
 require "or_tools/cp_solver_solution_callback"
@@ -16,6 +17,12 @@ require "or_tools/sat_int_var"
 require "or_tools/solver"
 require "or_tools/version"
 
+# higher level interfaces
+require "or_tools/basic_scheduler"
+require "or_tools/seating"
+require "or_tools/sudoku"
+require "or_tools/tsp"
+
 module ORTools
   class Error < StandardError; end
 end

data/lib/or_tools/basic_scheduler.rb

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