or-tools 0.13.0 → 0.14.0

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

data/lib/or_tools/mp_variable.rb

@@ -1,11 +0,0 @@
-module ORTools
-  class MPVariable < LinearExpr
-    def add_self_to_coeff_map_or_stack(coeffs, multiplier, stack)
-      coeffs[self] += multiplier
-    end
-
-    def to_s
-      name
-    end
-  end
-end

data/lib/or_tools/product_cst.rb

@@ -1,35 +0,0 @@
-module ORTools
-  class ProductCst < LinearExpr
-    attr_reader :expr, :coef
-
-    def initialize(expr, coef)
-      @expr = cast_to_lin_exp(expr)
-      # TODO improve message
-      raise TypeError, "expected numeric" unless coef.is_a?(Numeric)
-      @coef = coef
-    end
-
-    def to_s
-      if @coef == -1
-        "-#{@expr}"
-      else
-        expr = @expr.to_s
-        if expr.include?("+") || expr.include?("-")
-          expr = "(#{expr})"
-        end
-        "#{@coef} * #{expr}"
-      end
-    end
-
-    def add_self_to_coeff_map_or_stack(coeffs, multiplier, stack)
-      current_multiplier = multiplier * @coef
-      if current_multiplier
-        stack << [current_multiplier, @expr]
-      end
-    end
-
-    def cast_to_lin_exp(v)
-      v.is_a?(Numeric) ? Constant.new(v) : v
-    end
-  end
-end

data/lib/or_tools/sat_int_var.rb

@@ -1,29 +0,0 @@
-module ORTools
-  class SatIntVar
-    include ComparisonOperators
-
-    def *(other)
-      SatLinearExpr.new([[self, other]])
-    end
-
-    def +(other)
-      SatLinearExpr.new([[self, 1], [other, 1]])
-    end
-
-    def -(other)
-      SatLinearExpr.new([[self, 1], [-other, 1]])
-    end
-
-    def -@
-      SatLinearExpr.new([[self, -1]])
-    end
-
-    def to_s
-      name
-    end
-
-    def inspect
-      "#<#{self.class.name} #{to_s}>"
-    end
-  end
-end

data/lib/or_tools/sat_linear_expr.rb

@@ -1,59 +0,0 @@
-module ORTools
-  class SatLinearExpr
-    include ComparisonOperators
-
-    attr_reader :vars
-
-    def initialize(vars = [])
-      @vars = vars
-    end
-
-    def +(other)
-      add(other, 1)
-    end
-
-    def -(other)
-      add(other, -1)
-    end
-
-    def *(other)
-      if vars.size == 1
-        self.class.new([[vars[0][0], vars[0][1] * other]])
-      else
-        raise ArgumentError, "Multiplication not allowed here"
-      end
-    end
-
-    def to_s
-      vars.map do |v|
-        k = v[0]
-        k = k.respond_to?(:name) ? k.name : k.to_s
-        if v[1] == 1
-          k
-        else
-          "#{k} * #{v[1]}"
-        end
-      end.join(" + ").sub(" + -", " - ")
-    end
-
-    def inspect
-      "#<#{self.class.name} #{to_s}>"
-    end
-
-    private
-
-    def add(other, sign)
-      other_vars =
-        case other
-        when SatLinearExpr
-          other.vars
-        when BoolVar, SatIntVar, Integer
-          [[other, 1]]
-        else
-          raise ArgumentError, "Unsupported type: #{other.class.name}"
-        end
-
-      self.class.new(vars + other_vars.map { |a, b| [a, sign * b] })
-    end
-  end
-end

data/lib/or_tools/sum_array.rb

@@ -1,23 +0,0 @@
-module ORTools
-  class SumArray < LinearExpr
-    attr_reader :array
-
-    def initialize(array)
-      @array = array.map { |v| cast_to_lin_exp(v) }
-    end
-
-    def add_self_to_coeff_map_or_stack(coeffs, multiplier, stack)
-      @array.reverse_each do |arg|
-        stack << [multiplier, arg]
-      end
-    end
-
-    def cast_to_lin_exp(v)
-      v.is_a?(Numeric) ? Constant.new(v) : v
-    end
-
-    def to_s
-      "#{@array.map(&:to_s).reject { |v| v == "0" }.join(" + ")}".gsub(" + -", " - ")
-    end
-  end
-end