opt-rb 0.1.0

data/lib/opt/solvers/scs_solver.rb

@@ -0,0 +1,76 @@
+module Opt
+  module Solvers
+    class ScsSolver < AbstractSolver
+      def solve(sense:, col_lower:, col_upper:, obj:, row_lower:, row_upper:, constraints_by_var:, vars:, offset:, verbose:, time_limit:, **)
+        obj = obj.map { |v| -v } if sense == :maximize
+
+        a = []
+        b = []
+
+        # add variables to constraints
+        vars.each_with_index do |var, i|
+          if col_lower[i] != -Float::INFINITY
+            constraints_by_var << [{var => 1}, :>=, col_lower[i]]
+          end
+          if col_upper[i] != Float::INFINITY
+            constraints_by_var << [{var => 1}, :<=, col_upper[i]]
+          end
+        end
+
+        c1, c2 = constraints_by_var.partition { |_, op, _| op == :== }
+        z = c1.size
+        l = c2.size
+
+        c1.each do |left, _, right|
+          a << vars.map { |v| left[v] || 0 }
+          b << right
+        end
+
+        c2.each do |left, op, right|
+          ai = vars.map { |v| left[v] || 0 }
+          bi = right
+
+          if op == :>=
+            ai.map! { |v| v * -1 }
+            bi *= -1
+          end
+
+          a << ai
+          b << bi
+        end
+
+        data = {a: a, b: b, c: obj}
+        cone = {z: z, l: l}
+        solver = SCS::Solver.new
+        res = solver.solve(data, cone, verbose: verbose, time_limit_secs: time_limit)
+        objective = res[:pobj]
+        objective *= -1 if sense == :maximize
+        objective += offset
+
+        status =
+          case res[:status]
+          when "solved"
+            :optimal
+          when "infeasible", "unbounded"
+            res[:status].to_sym
+          else
+            res[:status]
+          end
+
+        {
+          status: status,
+          objective: objective,
+          x: res[:x]
+        }
+      end
+
+      def self.available?
+        defined?(SCS)
+      end
+
+      def self.supported_types
+        [:lp]
+      end
+    end
+  end
+end

data/lib/opt/variable.rb

@@ -0,0 +1,19 @@
+module Opt
+  class Variable < Expression
+    attr_reader :bounds, :name
+    attr_accessor :value
+
+    def initialize(bounds, name = nil)
+      @bounds = bounds
+      @name = name || "x#{object_id}"
+    end
+
+    def inspect
+      @name
+    end
+
+    def vars
+      @vars ||= [self]
+    end
+  end
+end

data/lib/opt/version.rb

@@ -0,0 +1,3 @@
+module Opt
+  VERSION = "0.1.0"
+end

data/lib/opt-rb.rb

@@ -0,0 +1 @@
+require_relative "opt"

data/lib/opt.rb

@@ -0,0 +1,46 @@
+# modules
+require_relative "opt/expression"
+require_relative "opt/comparison"
+require_relative "opt/constant"
+require_relative "opt/variable"
+require_relative "opt/integer"
+require_relative "opt/binary"
+require_relative "opt/problem"
+require_relative "opt/product"
+require_relative "opt/version"
+
+# solvers
+require_relative "opt/solvers/abstract_solver"
+require_relative "opt/solvers/cbc_solver"
+require_relative "opt/solvers/clp_solver"
+require_relative "opt/solvers/glop_solver"
+require_relative "opt/solvers/glpk_solver"
+require_relative "opt/solvers/highs_solver"
+require_relative "opt/solvers/osqp_solver"
+require_relative "opt/solvers/scs_solver"
+
+module Opt
+  class Error < StandardError; end
+
+  class << self
+    attr_accessor :solvers, :default_solvers
+  end
+  self.solvers = {}
+  self.default_solvers = {}
+
+  def self.register_solver(key, cls)
+    solvers[key] = cls
+  end
+
+  def self.available_solvers
+    solvers.select { |k, v| v.available? }.map(&:first)
+  end
+end
+
+Opt.register_solver :cbc, Opt::Solvers::CbcSolver
+Opt.register_solver :clp, Opt::Solvers::ClpSolver
+Opt.register_solver :glop, Opt::Solvers::GlopSolver
+Opt.register_solver :glpk, Opt::Solvers::GlpkSolver
+Opt.register_solver :highs, Opt::Solvers::HighsSolver
+Opt.register_solver :osqp, Opt::Solvers::OsqpSolver
+Opt.register_solver :scs, Opt::Solvers::ScsSolver

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: opt-rb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andrew Kane
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-01-26 00:00:00.000000000 Z
+dependencies: []
+description:
+email: andrew@ankane.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/opt-rb.rb
+- lib/opt.rb
+- lib/opt/binary.rb
+- lib/opt/comparison.rb
+- lib/opt/constant.rb
+- lib/opt/expression.rb
+- lib/opt/integer.rb
+- lib/opt/problem.rb
+- lib/opt/product.rb
+- lib/opt/solvers/abstract_solver.rb
+- lib/opt/solvers/cbc_solver.rb
+- lib/opt/solvers/clp_solver.rb
+- lib/opt/solvers/glop_solver.rb
+- lib/opt/solvers/glpk_solver.rb
+- lib/opt/solvers/highs_solver.rb
+- lib/opt/solvers/osqp_solver.rb
+- lib/opt/solvers/scs_solver.rb
+- lib/opt/variable.rb
+- lib/opt/version.rb
+homepage: https://github.com/ankane/opt
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.1
+signing_key:
+specification_version: 4
+summary: Convex optimization for Ruby
+test_files: []