or-tools 0.13.1 → 0.14.0

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)
@@ -21,25 +37,22 @@ module ORTools
     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

data/lib/or_tools/variable.rb

@@ -0,0 +1,29 @@
+module ORTools
+  module Variable
+    include ExpressionMethods
+
+    def inspect
+      name
+    end
+
+    def vars
+      @vars ||= [self]
+    end
+  end
+
+  class MPVariable
+    include Variable
+  end
+
+  class SatIntVar
+    include Variable
+  end
+
+  class SatBoolVar
+    include Variable
+  end
+
+  class RoutingIntVar
+    include Variable
+  end
+end

data/lib/or_tools/version.rb

@@ -1,3 +1,3 @@
 module ORTools
-  VERSION = "0.13.1"
+  VERSION = "0.14.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: or-tools
 version: !ruby/object:Gem::Version
-  version: 0.13.1
+  version: 0.14.0
 platform: ruby
 authors:
 - Andrew Kane
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-06 00:00:00.000000000 Z
+date: 2024-10-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rice
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.3'
+        version: 4.3.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.3'
+        version: 4.3.3
 description:
 email: andrew@ankane.org
 executables: []
@@ -42,36 +42,33 @@ files:
 - ext/or-tools/ext.h
 - ext/or-tools/extconf.rb
 - ext/or-tools/linear.cpp
+- ext/or-tools/math_opt.cpp
 - ext/or-tools/network_flows.cpp
 - ext/or-tools/routing.cpp
 - ext/or-tools/vendor.rb
 - lib/or-tools.rb
 - lib/or_tools/basic_scheduler.rb
-- lib/or_tools/bool_var.rb
 - lib/or_tools/comparison.rb
-- lib/or_tools/comparison_operators.rb
 - lib/or_tools/constant.rb
 - lib/or_tools/cp_model.rb
 - lib/or_tools/cp_solver.rb
 - lib/or_tools/cp_solver_solution_callback.rb
-- lib/or_tools/int_var.rb
+- lib/or_tools/expression.rb
 - lib/or_tools/knapsack_solver.rb
-- lib/or_tools/linear_constraint.rb
-- lib/or_tools/linear_expr.rb
-- lib/or_tools/mp_variable.rb
+- lib/or_tools/math_opt/model.rb
+- lib/or_tools/math_opt/variable.rb
 - lib/or_tools/objective_solution_printer.rb
-- lib/or_tools/product_cst.rb
+- lib/or_tools/product.rb
 - lib/or_tools/routing_index_manager.rb
 - lib/or_tools/routing_model.rb
-- lib/or_tools/sat_int_var.rb
-- lib/or_tools/sat_linear_expr.rb
 - lib/or_tools/seating.rb
 - lib/or_tools/solver.rb
 - lib/or_tools/sudoku.rb
-- lib/or_tools/sum_array.rb
 - lib/or_tools/tsp.rb
+- lib/or_tools/utils.rb
 - lib/or_tools/var_array_and_objective_solution_printer.rb
 - lib/or_tools/var_array_solution_printer.rb
+- lib/or_tools/variable.rb
 - lib/or_tools/version.rb
 homepage: https://github.com/ankane/or-tools-ruby
 licenses:

data/lib/or_tools/bool_var.rb

@@ -1,9 +0,0 @@
-module ORTools
-  class BoolVar
-    include ComparisonOperators
-
-    def *(other)
-      SatLinearExpr.new([[self, other]])
-    end
-  end
-end

data/lib/or_tools/comparison_operators.rb

@@ -1,9 +0,0 @@
-module ORTools
-  module ComparisonOperators
-    ["==", "!=", ">", ">=", "<", "<="].each do |operator|
-      define_method(operator) do |other|
-        Comparison.new(operator, self, other)
-      end
-    end
-  end
-end

data/lib/or_tools/int_var.rb

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

data/lib/or_tools/linear_constraint.rb

@@ -1,50 +0,0 @@
-module ORTools
-  class LinearConstraint
-    attr_reader :expr, :lb, :ub
-
-    def initialize(expr, lb, ub)
-      @expr = expr
-      @lb = lb
-      @ub = ub
-    end
-
-    def to_s
-      if @lb > -Float::INFINITY && @ub < Float::INFINITY
-        if @lb == @ub
-          "#{@expr} == #{@lb}"
-        else
-          "#{@lb} <= #{@expr} <= #{@ub}"
-        end
-      elsif @lb > -Float::INFINITY
-        "#{@expr} >= #{@lb}"
-      elsif @ub < Float::INFINITY
-        "#{@expr} <= #{@ub}"
-      else
-        "Trivial inequality (always true)"
-      end
-    end
-
-    def inspect
-      "#<#{self.class.name} #{to_s}>"
-    end
-
-    def extract(solver)
-      coeffs = @expr.coeffs
-      constant = coeffs.delete(OFFSET_KEY) || 0.0
-      lb = -solver.infinity
-      ub = solver.infinity
-      if @lb > -Float::INFINITY
-        lb = @lb - constant
-      end
-      if @ub < Float::INFINITY
-        ub = @ub - constant
-      end
-
-      constraint = solver.constraint(lb, ub)
-      coeffs.each do |v, c|
-        constraint.set_coefficient(v, c.to_f)
-      end
-      constraint
-    end
-  end
-end

data/lib/or_tools/linear_expr.rb

@@ -1,85 +0,0 @@
-module ORTools
-  class LinearExpr
-    def solution_value
-      coeffs.sum { |var, coeff| var.solution_value * coeff }
-    end
-
-    def coeffs
-      coeffs = Hash.new(0.0)
-      stack = [[1.0, self]]
-      while stack.any?
-        current_multiplier, current_expression = stack.pop
-
-        # skip empty LinearExpr for backwards compatibility
-        next if current_expression.instance_of?(LinearExpr)
-
-        current_expression.add_self_to_coeff_map_or_stack(coeffs, current_multiplier, stack)
-      end
-      coeffs
-    end
-
-    def +(expr)
-      SumArray.new([self, expr])
-    end
-
-    def -(expr)
-      SumArray.new([self, -expr])
-    end
-
-    def *(other)
-      if is_a?(Constant)
-        ProductCst.new(other, @val)
-      else
-        ProductCst.new(self, other)
-      end
-    end
-
-    def /(cst)
-      ProductCst.new(self, 1.0 / other)
-    end
-
-    def -@
-      ProductCst.new(self, -1)
-    end
-
-    def ==(arg)
-      if arg.is_a?(Numeric)
-        LinearConstraint.new(self, arg, arg)
-      else
-        LinearConstraint.new(self - arg, 0.0, 0.0)
-      end
-    end
-
-    def >=(arg)
-      if arg.is_a?(Numeric)
-        LinearConstraint.new(self, arg, Float::INFINITY)
-      else
-        LinearConstraint.new(self - arg, 0.0, Float::INFINITY)
-      end
-    end
-
-    def <=(arg)
-      if arg.is_a?(Numeric)
-        LinearConstraint.new(self, -Float::INFINITY, arg)
-      else
-        LinearConstraint.new(self - arg, -Float::INFINITY, 0.0)
-      end
-    end
-
-    def to_s
-      "(empty)"
-    end
-
-    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