opt-rb 0.1.0

data/lib/opt/problem.rb

@@ -0,0 +1,277 @@
+module Opt
+  class Problem
+    attr_reader :sense, :objective, :constraints
+
+    def initialize
+      @constraints = []
+      @indexed_constraints = []
+    end
+
+    def add(constraint)
+      raise ArgumentError, "Expected Comparison" unless constraint.is_a?(Comparison)
+
+      @constraints << constraint
+      @indexed_constraints << index_constraint(constraint)
+    end
+
+    def minimize(objective)
+      set_objective(:minimize, objective)
+    end
+
+    def maximize(objective)
+      set_objective(:maximize, objective)
+    end
+
+    def solve(solver: nil, verbose: false, time_limit: nil)
+      @indexed_objective ||= {}
+
+      vars = self.vars
+      raise Error, "No variables" if vars.empty?
+      type = vars.any? { |v| v.is_a?(Integer) } ? :mip : :lp
+      quadratic = @indexed_objective.any? { |k, _| k.is_a?(Array) }
+
+      if quadratic
+        raise Error, "Not supported" if type == :mip
+        type = :qp
+      end
+
+      raise Error, "No solvers found" if Opt.available_solvers.empty?
+
+      solver ||= (Opt.default_solvers[type] || Opt.available_solvers.find { |s| s.supports_type?(type) })
+      raise Error, "No solvers found for #{type}" unless solver
+
+      # TODO better error message
+      solver_cls = Opt.solvers.fetch(solver)
+      raise Error, "Solver does not support #{type}" unless solver_cls.supports_type?(type)
+
+      col_lower = []
+      col_upper = []
+      obj = []
+
+      @sense ||= :minimize
+
+      vars.each do |var|
+        col_lower << (var.bounds.begin || -Float::INFINITY)
+        upper = var.bounds.end
+        if upper && var.bounds.exclude_end?
+          if var.is_a?(Integer)
+            upper -= 1
+          else
+            upper -= Float::EPSILON
+          end
+        end
+        col_upper << (upper || Float::INFINITY)
+        obj << (@indexed_objective[var] || 0)
+      end
+
+      row_lower = []
+      row_upper = []
+      constraints_by_var = @indexed_constraints
+      constraints_by_var.each do |left, op, right|
+        case op
+        when :>=
+          row_lower << right
+          row_upper << Float::INFINITY
+        when :<=
+          row_lower << -Float::INFINITY
+          row_upper << right
+        else # :==
+          row_lower << right
+          row_upper << right
+        end
+      end
+
+      start = []
+      index = []
+      value = []
+
+      vars.each do |var|
+        start << index.size
+        constraints_by_var.map(&:first).each_with_index do |ic, i|
+          if ic[var]
+            index << i
+            value << ic[var]
+          end
+        end
+      end
+      start << index.size
+
+      if type == :qp
+        @indexed_objective.select { |k, _| k.is_a?(Array) }.each do |k, v|
+          @indexed_objective[k.reverse] = v
+        end
+      end
+
+      res = solver_cls.new.solve(
+        sense: @sense, start: start, index: index, value: value,
+        col_lower: col_lower, col_upper: col_upper, obj: obj,
+        row_lower: row_lower, row_upper: row_upper,
+        constraints_by_var: constraints_by_var, vars: vars,
+        offset: @indexed_objective[nil] || 0, verbose: verbose,
+        type: type, time_limit: time_limit, indexed_objective: @indexed_objective
+      )
+
+      if res[:status] == :optimal
+        vars.zip(res.delete(:x)) do |a, b|
+          a.value =
+            case a
+            when Binary
+              b.round != 0
+            when Integer
+              b.round
+            else
+              b
+            end
+        end
+      else
+        res.delete(:objective)
+        res.delete(:x)
+      end
+      res
+    end
+
+    def inspect
+      str = String.new("")
+      str << "#{@sense}\n  #{@objective.inspect}\n"
+      str << "subject to\n"
+      @constraints.each do |constraint|
+        str << "  #{constraint.inspect}\n"
+      end
+      str << "vars\n"
+      vars.each do |var|
+        bounds = var.bounds
+        end_op = bounds.exclude_end? ? "<" : "<="
+        var_str =
+          if bounds.begin && bounds.end
+            "#{bounds.begin} <= #{var.name} #{end_op} #{bounds.end}"
+          elsif var.bounds.begin
+            "#{var.name} >= #{bounds.begin}"
+          else
+            "#{var.name} #{end_op} #{bounds.end}"
+          end
+        str << "  #{var_str}\n"
+      end
+      str
+    end
+
+    private
+
+    def vars
+      vars = []
+      vars.concat(@objective.vars) if @objective
+      @constraints.each do |constraint|
+        vars.concat(constraint.left.vars)
+        vars.concat(constraint.right.vars)
+      end
+      vars.uniq
+    end
+
+    def set_objective(sense, objective)
+      raise Error, "Objective already set" if @sense
+
+      @sense = sense
+      @objective = Expression.to_expression(objective)
+      @indexed_objective = index_expression(@objective)
+    end
+
+    def index_constraint(constraint)
+      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 index_expression(expression, check_linear: false)
+      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)
+      else # Expression
+        expression.parts.each do |part|
+          index_expression(part, check_linear: check_linear).each do |k, v|
+            vars[k] += v
+          end
+        end
+      end
+      vars
+    end
+
+    def 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 quad_key(left, right)
+      if left.object_id <= right.object_id
+        [left, right]
+      else
+        [right, left]
+      end
+    end
+  end
+end

data/lib/opt/product.rb

@@ -0,0 +1,28 @@
+module Opt
+  class Product < Expression
+    attr_reader :left, :right
+
+    def initialize(left, right)
+      @left = left
+      @right = right
+    end
+
+    def inspect
+      "#{inspect_part(@left)} * #{inspect_part(@right)}"
+    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/opt/solvers/abstract_solver.rb

@@ -0,0 +1,9 @@
+module Opt
+  module Solvers
+    class AbstractSolver
+      def self.supports_type?(type)
+        supported_types.include?(type)
+      end
+    end
+  end
+end

data/lib/opt/solvers/cbc_solver.rb

@@ -0,0 +1,49 @@
+module Opt
+  module Solvers
+    class CbcSolver < AbstractSolver
+      def solve(sense:, start:, index:, value:, col_lower:, col_upper:, obj:, row_lower:, row_upper:, offset:, verbose:, time_limit:, vars:, **)
+        model =
+          Cbc.load_problem(
+            sense: sense,
+            start: start,
+            index: index,
+            value: value,
+            col_lower: col_lower,
+            col_upper: col_upper,
+            obj: obj,
+            row_lower: row_lower,
+            row_upper: row_upper,
+            col_type: vars.map { |v| v.is_a?(Integer) ? :integer : :continuous }
+          )
+
+        # only pass options if set to support Cbc < 2.10.0
+        options = {}
+        options[:log_level] = 1 if verbose
+        options[:time_limit] = time_limit if time_limit
+        res = model.solve(**options)
+
+        status =
+          case res[:status]
+          when :primal_infeasible
+            :infeasible
+          else
+            res[:status]
+          end
+
+        {
+          status: status,
+          objective: res[:objective] + offset,
+          x: res[:primal_col]
+        }
+      end
+
+      def self.available?
+        defined?(Cbc)
+      end
+
+      def self.supported_types
+        [:lp, :mip]
+      end
+    end
+  end
+end

data/lib/opt/solvers/clp_solver.rb

@@ -0,0 +1,46 @@
+module Opt
+  module Solvers
+    class ClpSolver < AbstractSolver
+      def solve(sense:, start:, index:, value:, col_lower:, col_upper:, obj:, row_lower:, row_upper:, offset:, verbose:, time_limit:, **)
+        model =
+          Clp.load_problem(
+            sense: sense,
+            start: start,
+            index: index,
+            value: value,
+            col_lower: col_lower,
+            col_upper: col_upper,
+            obj: obj,
+            row_lower: row_lower,
+            row_upper: row_upper,
+            offset: -offset
+          )
+        res = model.solve(log_level: verbose ? 4 : nil, time_limit: time_limit)
+
+        status =
+          case res[:status]
+          when :primal_infeasible
+            :infeasible
+          when :dual_infeasible
+            :unbounded
+          else
+            res[:status]
+          end
+
+        {
+          status: status,
+          objective: res[:objective],
+          x: res[:primal_col]
+        }
+      end
+
+      def self.available?
+        defined?(Clp)
+      end
+
+      def self.supported_types
+        [:lp]
+      end
+    end
+  end
+end

data/lib/opt/solvers/glop_solver.rb

@@ -0,0 +1,56 @@
+module Opt
+  module Solvers
+    class GlopSolver < AbstractSolver
+      def solve(sense:, col_lower:, col_upper:, obj:, offset:, verbose:, time_limit:, constraints_by_var:, vars:, **)
+        solver = ORTools::Solver.new("GLOP")
+
+        # create vars
+        vars2 =
+          vars.map.with_index do |v, i|
+            solver.num_var(col_lower[i], col_upper[i], v.name)
+          end
+
+        var_index = vars.map.with_index.to_h
+
+        # add constraints
+        constraints_by_var.each do |left, op, right|
+          expr = left.sum { |k, v| vars2[var_index[k]] * v }
+          case op
+          when :<=
+            solver.add(expr <= right)
+          when :>=
+            solver.add(expr >= right)
+          else
+            solver.add(expr == right)
+          end
+        end
+
+        # add objective
+        objective = vars2.zip(obj).sum { |v, o| v * o }
+
+        if sense == :maximize
+          solver.maximize(objective)
+        else
+          solver.minimize(objective)
+        end
+
+        solver.time_limit = time_limit if time_limit
+        status = solver.solve
+
+        {
+          status: status,
+          objective: solver.objective.value + offset,
+          x: vars2.map(&:solution_value)
+        }
+      end
+
+      def self.available?
+        defined?(ORTools)
+      end
+
+      def self.supported_types
+        [:lp]
+      end
+    end
+  end
+end

data/lib/opt/solvers/glpk_solver.rb

@@ -0,0 +1,72 @@
+module Opt
+  module Solvers
+    class GlpkSolver < AbstractSolver
+      def solve(sense:, start:, index:, value:, col_lower:, col_upper:, obj:, row_lower:, row_upper:, offset:, verbose:, time_limit:, vars:, **)
+        col_kind =
+          vars.map do |v|
+            case v
+            when Binary
+              :binary
+            when Integer
+              :integer
+            else
+              :continuous
+            end
+          end
+
+        mat_ia = []
+        mat_ja = []
+        mat_ar = []
+        start.each_with_index do |s, j|
+          rng = s...start[j + 1]
+          index[rng].zip(value[rng]) do |i, v|
+            mat_ia << i + 1
+            mat_ja << j + 1
+            mat_ar << v
+          end
+        end
+
+        model =
+          Glpk.load_problem(
+            obj_dir: sense,
+            obj_coef: obj,
+            mat_ia: mat_ia,
+            mat_ja: mat_ja,
+            mat_ar: mat_ar,
+            col_kind: col_kind,
+            col_lower: col_lower,
+            col_upper: col_upper,
+            row_lower: row_lower,
+            row_upper: row_upper,
+          )
+        res = model.solve(message_level: verbose ? 3 : 0, time_limit: time_limit)
+
+        status =
+          case res[:status]
+          when :no_feasible, :no_primal_feasible
+            :infeasible
+          else
+            res[:status]
+          end
+
+        if status == :optimal && !res[:obj_val].finite?
+          status = :unbounded
+        end
+
+        {
+          status: status,
+          objective: res[:obj_val] + offset,
+          x: res[:col_primal]
+        }
+      end
+
+      def self.available?
+        defined?(Glpk)
+      end
+
+      def self.supported_types
+        [:lp, :mip]
+      end
+    end
+  end
+end

data/lib/opt/solvers/highs_solver.rb

@@ -0,0 +1,92 @@
+module Opt
+  module Solvers
+    class HighsSolver < AbstractSolver
+      def solve(sense:, start:, index:, value:, col_lower:, col_upper:, obj:, row_lower:, row_upper:, vars:, offset:, verbose:, type:, time_limit:, indexed_objective:, **)
+        start.pop
+
+        model =
+          case type
+          when :mip
+            Highs.mip(
+              sense: sense,
+              col_cost: obj,
+              col_lower: col_lower,
+              col_upper: col_upper,
+              row_lower: row_lower,
+              row_upper: row_upper,
+              a_format: :colwise,
+              a_start: start,
+              a_index: index,
+              a_value: value,
+              offset: offset,
+              integrality: vars.map { |v| v.is_a?(Integer) ? 1 : 0 }
+            )
+          when :qp
+            q_start = []
+            q_index = []
+            q_value = []
+
+            vars.each_with_index do |v2, j|
+              q_start << q_index.size
+              vars.each_with_index do |v1, i|
+                v = indexed_objective[[v1, v2]]
+                if v != 0
+                  q_index << i
+                  # multiply values by 2 since minimizes 1/2
+                  q_value << (v1.equal?(v2) ? v * 2 : v)
+                end
+              end
+            end
+
+            Highs.qp(
+              sense: sense,
+              col_cost: obj,
+              col_lower: col_lower,
+              col_upper: col_upper,
+              row_lower: row_lower,
+              row_upper: row_upper,
+              a_format: :colwise,
+              a_start: start,
+              a_index: index,
+              a_value: value,
+              offset: offset,
+              q_format: :colwise,
+              q_start: q_start,
+              q_index: q_index,
+              q_value: q_value
+            )
+          else
+            Highs.lp(
+              sense: sense,
+              col_cost: obj,
+              col_lower: col_lower,
+              col_upper: col_upper,
+              row_lower: row_lower,
+              row_upper: row_upper,
+              a_format: :colwise,
+              a_start: start,
+              a_index: index,
+              a_value: value,
+              offset: offset
+            )
+          end
+
+        res = model.solve(verbose: verbose, time_limit: time_limit)
+
+        {
+          status: res[:status],
+          objective: res[:obj_value],
+          x: res[:col_value]
+        }
+      end
+
+      def self.available?
+        defined?(Highs)
+      end
+
+      def self.supported_types
+        [:lp, :qp, :mip]
+      end
+    end
+  end
+end

data/lib/opt/solvers/osqp_solver.rb

@@ -0,0 +1,73 @@
+module Opt
+  module Solvers
+    class OsqpSolver < AbstractSolver
+      def solve(sense:, col_lower:, col_upper:, obj:, row_lower:, row_upper:, constraints_by_var:, vars:, offset:, verbose:, time_limit:, type:, indexed_objective:, **)
+        obj = obj.map { |v| -v } if sense == :maximize
+
+        a =
+          constraints_by_var.map(&:first).map do |ic|
+            vars.map do |var|
+              ic[var] || 0
+            end
+          end
+
+        # add variable constraints
+        vars.each_with_index do |v, i|
+          row = [0] * vars.size
+          row[i] = 1
+          a << row
+          row_lower << col_lower[i]
+          row_upper << col_upper[i]
+        end
+
+        p = OSQP::Matrix.new(a.first.size, a.first.size)
+        if type == :qp
+          vars.map.with_index do |v1, i|
+            vars.map.with_index do |v2, j|
+              if i > j
+                0
+              else
+                v = indexed_objective[[v1, v2]]
+                v = (v1.equal?(v2) ? v * 2 : v)
+                v *= -1 if sense == :maximize
+                p[i, j] = v
+              end
+            end
+          end
+        end
+
+        solver = OSQP::Solver.new
+        res = solver.solve(p, obj, a, row_lower, row_upper, verbose: verbose, time_limit: time_limit, polish: true)
+        objective = res[:obj_val]
+        objective *= -1 if sense == :maximize
+        objective += offset
+
+        status =
+          case res[:status]
+          when "solved"
+            :optimal
+          when "primal infeasible"
+            :infeasible
+          when "dual infeasible"
+            :unbounded
+          else
+            res[:status]
+          end
+
+        {
+          status: status,
+          objective: objective,
+          x: res[:x]
+        }
+      end
+
+      def self.available?
+        defined?(OSQP)
+      end
+
+      def self.supported_types
+        [:lp, :qp]
+      end
+    end
+  end
+end