or-tools 0.13.1 → 0.14.1

data/ext/or-tools/routing.cpp

@@ -56,22 +56,9 @@ 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");
+  auto rb_cIntVar = Rice::define_class_under<operations_research::IntVar>(m, "RoutingIntVar");
 
   m.define_singleton_function("default_routing_search_parameters", &DefaultRoutingSearchParameters);
 
@@ -213,7 +200,6 @@ void init_routing(Rice::Module& m) {
 
   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)
@@ -239,7 +225,7 @@ void init_routing(Rice::Module& m) {
     .define_method("post", &operations_research::Constraint::Post)
     .define_method("debug_string", &operations_research::Constraint::DebugString);
 
-  Rice::define_class_under<operations_research::Solver>(m, "Solver2")
+  Rice::define_class_under<operations_research::Solver>(m, "RoutingSolver")
     .define_method(
       "add",
       [](operations_research::Solver& self, Object o) {
@@ -247,7 +233,7 @@ void init_routing(Rice::Module& m) {
         if (o.respond_to("left")) {
           operations_research::IntExpr* left(Rice::detail::From_Ruby<operations_research::IntVar*>().convert(o.call("left")));
           operations_research::IntExpr* right(Rice::detail::From_Ruby<operations_research::IntVar*>().convert(o.call("right")));
-          auto op = o.call("operator").to_s().str();
+          auto op = o.call("op").to_s().str();
           if (op == "==") {
             constraint = self.MakeEquality(left, right);
           } else if (op == "<=") {
@@ -304,8 +290,13 @@ void init_routing(Rice::Module& m) {
     .define_method(
       "register_unary_transit_callback",
       [](RoutingModel& self, Object callback) {
+        // TODO guard callback?
         return self.RegisterUnaryTransitCallback(
           [callback](int64_t from_index) -> int64_t {
+            if (!ruby_native_thread_p()) {
+              throw std::runtime_error("Non-Ruby thread");
+            }
+
             return Rice::detail::From_Ruby<int64_t>().convert(callback.call("call", from_index));
           }
         );
@@ -314,8 +305,13 @@ void init_routing(Rice::Module& m) {
     .define_method(
       "register_transit_callback",
       [](RoutingModel& self, Object callback) {
+        // TODO guard callback?
         return self.RegisterTransitCallback(
           [callback](int64_t from_index, int64_t to_index) -> int64_t {
+            if (!ruby_native_thread_p()) {
+              throw std::runtime_error("Non-Ruby thread");
+            }
+
             return Rice::detail::From_Ruby<int64_t>().convert(callback.call("call", from_index, to_index));
           }
         );
@@ -328,13 +324,8 @@ void init_routing(Rice::Module& m) {
     .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)
@@ -373,9 +364,6 @@ void init_routing(Rice::Module& m) {
         }
         return positions;
       })
-    // 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)
@@ -444,8 +432,6 @@ void init_routing(Rice::Module& m) {
     .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)

data/lib/or-tools.rb

@@ -1,39 +1,50 @@
 # ext
 require "or_tools/ext"
 
-# modules
+# expressions
+require_relative "or_tools/expression"
 require_relative "or_tools/comparison"
-require_relative "or_tools/comparison_operators"
-require_relative "or_tools/bool_var"
 require_relative "or_tools/constant"
+require_relative "or_tools/product"
+require_relative "or_tools/variable"
+
+# bin packing
+require_relative "or_tools/knapsack_solver"
+
+# constraint
 require_relative "or_tools/cp_model"
 require_relative "or_tools/cp_solver"
 require_relative "or_tools/cp_solver_solution_callback"
-require_relative "or_tools/int_var"
-require_relative "or_tools/knapsack_solver"
-require_relative "or_tools/linear_constraint"
-require_relative "or_tools/linear_expr"
-require_relative "or_tools/mp_variable"
-require_relative "or_tools/product_cst"
-require_relative "or_tools/routing_index_manager"
-require_relative "or_tools/routing_model"
-require_relative "or_tools/sat_linear_expr"
-require_relative "or_tools/sat_int_var"
-require_relative "or_tools/solver"
-require_relative "or_tools/sum_array"
-require_relative "or_tools/version"
-
-# solution printers
 require_relative "or_tools/objective_solution_printer"
 require_relative "or_tools/var_array_solution_printer"
 require_relative "or_tools/var_array_and_objective_solution_printer"
 
+# linear
+require_relative "or_tools/solver"
+
+# math opt
+require_relative "or_tools/math_opt/model"
+require_relative "or_tools/math_opt/variable"
+
+# routing
+require_relative "or_tools/routing_index_manager"
+require_relative "or_tools/routing_model"
+
 # higher level interfaces
 require_relative "or_tools/basic_scheduler"
 require_relative "or_tools/seating"
 require_relative "or_tools/sudoku"
 require_relative "or_tools/tsp"
 
+# modules
+require_relative "or_tools/utils"
+require_relative "or_tools/version"
+
 module ORTools
   class Error < StandardError; end
+
+  # previous names
+  Solver2 = RoutingSolver
+  IntVar = RoutingIntVar
+  BoolVar = SatBoolVar
 end

data/lib/or_tools/comparison.rb

@@ -1,19 +1,16 @@
 module ORTools
   class Comparison
-    attr_reader :operator, :left, :right
+    attr_reader :left, :op, :right
 
-    def initialize(operator, left, right)
-      @operator = operator
-      @left = left
-      @right = right
-    end
-
-    def to_s
-      "#{left} #{operator} #{right}"
+    def initialize(left, op, right)
+      @left = Expression.to_expression(left)
+      @op = op
+      @right = Expression.to_expression(right)
     end
 
     def inspect
-      "#<#{self.class.name} #{to_s}>"
+      "#{@left.inspect} #{@op} #{@right.inspect}"
     end
+    alias_method :to_s, :inspect
   end
 end

data/lib/or_tools/constant.rb

@@ -1,23 +1,26 @@
 module ORTools
-  class Constant < LinearExpr
-    def initialize(val)
-      @val = val
+  class Constant < Expression
+    attr_reader :value
+
+    def initialize(value)
+      @value = value
     end
 
-    def to_s
-      @val.to_s
+    # simplify Ruby sum
+    def +(other)
+      @value == 0 ? other : super
     end
 
-    def add_self_to_coeff_map_or_stack(coeffs, multiplier, stack)
-      coeffs[OFFSET_KEY] += @val * multiplier
+    def inspect
+      @value.to_s
     end
-  end
 
-  class FakeMPVariableRepresentingTheConstantOffset
-    def solution_value
-      1
+    def -@
+      Constant.new(-value)
     end
-  end
 
-  OFFSET_KEY = FakeMPVariableRepresentingTheConstantOffset.new
+    def vars
+      @vars ||= []
+    end
+  end
 end

data/lib/or_tools/cp_model.rb

@@ -4,18 +4,18 @@ module ORTools
       case comparison
       when Comparison
         method_name =
-          case comparison.operator
-          when "=="
+          case comparison.op
+          when :==
             :add_equality
-          when "!="
+          when :!=
             :add_not_equal
-          when ">"
+          when :>
             :add_greater_than
-          when ">="
+          when :>=
             :add_greater_or_equal
-          when "<"
+          when :<
             :add_less_than
-          when "<="
+          when :<=
             :add_less_or_equal
           else
             raise ArgumentError, "Unknown operator: #{comparison.operator}"
@@ -32,7 +32,7 @@ module ORTools
     end
 
     def sum(arr)
-      arr.sum(SatLinearExpr.new)
+      Expression.new(arr)
     end
 
     def inspect

data/lib/or_tools/cp_solver_solution_callback.rb

@@ -5,16 +5,16 @@ module ORTools
     def value(expr)
       case expr
       when SatIntVar
-        @response.solution_integer_value(expr)
+        @response&.solution_integer_value(expr)
       when BoolVar
-        @response.solution_boolean_value(expr)
+        @response&.solution_boolean_value(expr)
       else
         raise "Unsupported type: #{expr.class.name}"
       end
     end
 
     def objective_value
-      @response.objective_value
+      @response&.objective_value
     end
   end
 end

data/lib/or_tools/expression.rb

@@ -0,0 +1,85 @@
+module ORTools
+  module ExpressionMethods
+    attr_reader :parts
+
+    def +(other)
+      Expression.new((parts || [self]) + [Expression.to_expression(other)])
+    end
+
+    def -(other)
+      Expression.new((parts || [self]) + [-Expression.to_expression(other)])
+    end
+
+    def -@
+      -1 * self
+    end
+
+    def *(other)
+      Expression.new([Product.new(self, Expression.to_expression(other))])
+    end
+
+    def >(other)
+      Comparison.new(self, :>, other)
+    end
+
+    def <(other)
+      Comparison.new(self, :<, other)
+    end
+
+    def >=(other)
+      Comparison.new(self, :>=, other)
+    end
+
+    def <=(other)
+      Comparison.new(self, :<=, other)
+    end
+
+    def ==(other)
+      Comparison.new(self, :==, other)
+    end
+
+    def !=(other)
+      Comparison.new(self, :!=, other)
+    end
+
+    def inspect
+      @parts.reject { |v| v.is_a?(Constant) && v.value == 0 }.map(&:inspect).join(" + ").gsub(" + -", " - ")
+    end
+
+    def to_s
+      inspect
+    end
+
+    # keep order
+    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
+
+    def vars
+      @vars ||= @parts.flat_map(&:vars)
+    end
+  end
+
+  class Expression
+    include ExpressionMethods
+
+    def initialize(parts = [])
+      @parts = parts
+    end
+
+    # private
+    def self.to_expression(other)
+      if other.is_a?(Numeric)
+        Constant.new(other)
+      elsif other.is_a?(Variable) || other.is_a?(Expression)
+        other
+      else
+        raise TypeError, "can't cast #{other.class.name} to Expression"
+      end
+    end
+  end
+end

data/lib/or_tools/math_opt/model.rb

@@ -0,0 +1,54 @@
+module ORTools
+  module MathOpt
+    class Model
+      def add_linear_constraint(expr)
+        left, op, const = Utils.index_constraint(expr)
+
+        constraint = _add_linear_constraint
+        left.each do |var, c|
+          _set_coefficient(constraint, var, c)
+        end
+        case op
+        when :<=
+          _set_upper_bound(constraint, const)
+        when :>=
+          _set_lower_bound(constraint, const)
+        when :==
+          _set_lower_bound(constraint, const)
+          _set_upper_bound(constraint, const)
+        else
+          raise ArgumentError, "Supported operations are ==, <=, and >="
+        end
+        nil
+      end
+
+      def maximize(objective)
+        set_objective(objective)
+        _set_maximize
+      end
+
+      def minimize(objective)
+        set_objective(objective)
+        _set_minimize
+      end
+
+      # TODO change default for MIP
+      def solve(solver_type = :glop)
+        _solve(solver_type)
+      end
+
+      private
+
+      def set_objective(objective)
+        objective = Expression.to_expression(objective)
+        coeffs = Utils.index_expression(objective, check_linear: true)
+        offset = coeffs.delete(nil)
+
+        objective.set_offset(offset) if offset
+        coeffs.each do |var, c|
+          _set_objective_coefficient(var, c)
+        end
+      end
+    end
+  end
+end

data/lib/or_tools/math_opt/variable.rb

@@ -0,0 +1,15 @@
+module ORTools
+  module MathOpt
+    class Variable
+      include ORTools::Variable
+
+      def eql?(other)
+        other.is_a?(self.class) && _eql?(other)
+      end
+
+      def hash
+        id.hash
+      end
+    end
+  end
+end

data/lib/or_tools/product.rb

@@ -0,0 +1,32 @@
+module ORTools
+  class Product < Expression
+    attr_reader :left, :right
+
+    def initialize(left, right)
+      @left = left
+      @right = right
+    end
+
+    def inspect
+      if @left.is_a?(Constant) && @right.is_a?(Variable) && left.value == -1
+         "-#{inspect_part(@right)}"
+      else
+        "#{inspect_part(@left)} * #{inspect_part(@right)}"
+      end
+    end
+
+    def vars
+      @vars ||= (@left.vars + @right.vars).uniq
+    end
+
+    private
+
+    def inspect_part(var)
+      if var.instance_of?(Expression)
+        "(#{var.inspect})"
+      else
+        var.inspect
+      end
+    end
+  end
+end

data/lib/or_tools/solver.rb

@@ -1,11 +1,27 @@
 module ORTools
   class Solver
     def sum(arr)
-      SumArray.new(arr)
+      Expression.new(arr)
     end
 
     def add(expr)
-      expr.extract(self)
+      left, op, const = Utils.index_constraint(expr)
+
+      constraint =
+        case op
+        when :<=
+          self.constraint(-infinity, const)
+        when :>=
+          self.constraint(const, infinity)
+        when :==
+          self.constraint(const, const)
+        else
+          raise ArgumentError, "Supported operations are ==, <=, and >="
+        end
+      left.each do |var, c|
+        constraint.set_coefficient(var, c)
+      end
+      nil
     end
 
     def maximize(expr)
@@ -18,28 +34,30 @@ module ORTools
       objective.set_minimization
     end
 
+    def solve(parameters = nil)
+      parameters ||= MPSolverParameters.new
+      _solve(parameters)
+    end
+
     private
 
     def set_objective(expr)
+      coeffs = Utils.index_expression(expr, check_linear: true)
+      offset = coeffs.delete(nil)
+
       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)
+      coeffs.each do |var, c|
+        objective.set_coefficient(var, c)
       end
     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
+    def self.new(solver_id, *args)
+      if args.empty?
+        _create(solver_id)
+      else
+        _new(solver_id, *args)
       end
     end
-    singleton_class.prepend(m)
   end
 end

data/lib/or_tools/utils.rb

@@ -0,0 +1,107 @@
+module ORTools
+  module Utils
+    def self.index_constraint(constraint)
+      raise ArgumentError, "Expected Comparison" unless constraint.is_a?(Comparison)
+
+      left = index_expression(constraint.left, check_linear: true)
+      right = index_expression(constraint.right, check_linear: true)
+
+      const = right.delete(nil).to_f - left.delete(nil).to_f
+      right.each do |k, v|
+        left[k] -= v
+      end
+
+      [left, constraint.op, const]
+    end
+
+    def self.index_expression(expression, check_linear: true)
+      vars = Hash.new(0)
+      case expression
+      when Numeric
+        vars[nil] += expression
+      when Constant
+        vars[nil] += expression.value
+      when Variable
+        vars[expression] += 1
+      when Product
+        if check_linear && expression.left.vars.any? && expression.right.vars.any?
+          raise ArgumentError, "Nonlinear"
+        end
+        vars = index_product(expression.left, expression.right)
+      when Expression
+        expression.parts.each do |part|
+          index_expression(part, check_linear: check_linear).each do |k, v|
+            vars[k] += v
+          end
+        end
+      else
+        raise TypeError, "Unsupported type"
+      end
+      vars
+    end
+
+    def self.index_product(left, right)
+      # normalize
+      types = [Constant, Variable, Product, Expression]
+      if types.index { |t| left.is_a?(t) } > types.index { |t| right.is_a?(t) }
+        left, right = right, left
+      end
+
+      vars = Hash.new(0)
+      case left
+      when Constant
+        vars = index_expression(right)
+        vars.transform_values! { |v| v * left.value }
+      when Variable
+        case right
+        when Variable
+          vars[quad_key(left, right)] = 1
+        when Product
+          index_expression(right).each do |k, v|
+            case k
+            when Array
+              raise Error, "Non-quadratic"
+            when Variable
+              vars[quad_key(left, k)] = v
+            else # nil
+              raise "Bug?"
+            end
+          end
+        else
+          right.parts.each do |part|
+            index_product(left, part).each do |k, v|
+              vars[k] += v
+            end
+          end
+        end
+      when Product
+        index_expression(left).each do |lk, lv|
+          index_expression(right).each do |rk, rv|
+            if lk.is_a?(Variable) && rk.is_a?(Variable)
+              vars[quad_key(lk, rk)] = lv * rv
+            else
+              raise "todo"
+            end
+          end
+        end
+      else # Expression
+        left.parts.each do |lp|
+          right.parts.each do |rp|
+            index_product(lp, rp).each do |k, v|
+              vars[k] += v
+            end
+          end
+        end
+      end
+      vars
+    end
+
+    def self.quad_key(left, right)
+      if left.object_id <= right.object_id
+        [left, right]
+      else
+        [right, left]
+      end
+    end
+  end
+end