scs 0.2.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cf0730fd042983c36ce96ea46ad28c0a330c5765e1521f8cfb28eb3321507df9
+  data.tar.gz: 677ebb1dc72dc2c1e51857c8644a11e91f9a332c95574ee8c452e31f36f4ec88
+SHA512:
+  metadata.gz: 889d538aba521314bc093e11fc584eb58f519116f72fedcab865b9a49a44fec44eaffbc20e28d1f2673c294922474c7ccc91f7ee7f0b08243c9e20ae52150e3c
+  data.tar.gz: 25ca5f1af62a227f1f05c34031d8f1554e1b9121c2d8c43bb40c4bd12d0af5d106b73a601f8abb8a3849fbdcde310b51a2fecfe17bb9e4bba4d3a70e5fd59fff

data/CHANGELOG.md

@@ -0,0 +1,12 @@
+## 0.2.2 (2020-07-21)
+
+- Updated SCS to 2.1.2
+
+## 0.2.1 (2019-11-29)
+
+- Fixed installation on Windows
+- Removed dependency on rake for installation
+
+## 0.2.0 (2019-11-16)
+
+- First release

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2019-2020 Andrew Kane
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,98 @@
+# SCS
+
+[SCS](https://github.com/cvxgrp/scs) - the splitting conic solver - for Ruby
+
+:fire: Supports many different [problem types](https://www.cvxpy.org/tutorial/advanced/index.html#choosing-a-solver)
+
+[![Build Status](https://travis-ci.org/ankane/scs.svg?branch=master)](https://travis-ci.org/ankane/scs) [![Build status](https://ci.appveyor.com/api/projects/status/wyn0cbgs0k5vg5tq/branch/master?svg=true)](https://ci.appveyor.com/project/ankane/scs/branch/master)
+
+## Installation
+
+Add this line to your application’s Gemfile:
+
+```ruby
+gem 'scs'
+```
+
+If installation fails, you may need to install [dependencies](#dependencies).
+
+## Getting Started
+
+Prep the problem
+
+```ruby
+data = {a: [[1], [-1]], b: [1, 0], c: [-1]}
+cone = {q: [], l: 2}
+```
+
+And solve it
+
+```ruby
+solver = SCS::Solver.new
+solver.solve(data, cone)
+```
+
+## Settings
+
+Default values shown
+
+```ruby
+solver.solve(data, cone, {
+  normalize: true,            # heuristic data rescaling
+  scale: 1.0,                 # if normalized, rescales by this factor
+  rho_x: 1e-3,                # x equality constraint scaling
+  max_iters: 5000,            # maximum iterations to take
+  eps: 1e-5,                  # convergence tolerance
+  alpha: 1.5,                 # relaxation parameter
+  cg_rate: 2.0,               # for indirect, tolerance goes down like (1/iter)^cg_rate
+  verbose: true,              # write out progress
+  warm_start: false,          # warm start
+  acceleration_lookback: 10,  # memory for acceleration
+  write_data_filename: nil    # filename to write data if set
+})
+```
+
+## Direct vs Indirect
+
+SCS comes with two solvers: a direct solver which uses a cached LDL factorization and an indirect solver based on conjugate gradients. For the indirect solver, use:
+
+```ruby
+SCS::Solver.new(indirect: true)
+```
+
+## Dependencies
+
+BLAS and LAPACK are required for SCS.
+
+```sh
+sudo apt-get install libblas-dev liblapack-dev
+```
+
+On Heroku, use the [heroku-apt-buildpack](https://github.com/heroku/heroku-buildpack-apt).
+
+## Resources
+
+- [Conic Optimization via Operator Splitting and Homogeneous Self-Dual Embedding](https://web.stanford.edu/~boyd/papers/scs.html)
+
+## History
+
+View the [changelog](https://github.com/ankane/scs/blob/master/CHANGELOG.md)
+
+## Contributing
+
+Everyone is encouraged to help improve this project. Here are a few ways you can help:
+
+- [Report bugs](https://github.com/ankane/scs/issues)
+- Fix bugs and [submit pull requests](https://github.com/ankane/scs/pulls)
+- Write, clarify, or fix documentation
+- Suggest or add new features
+
+To get started with development:
+
+```sh
+git clone --recursive https://github.com/ankane/scs.git
+cd scs
+bundle install
+bundle exec rake compile
+bundle exec rake test
+```

data/ext/scs/extconf.rb

@@ -0,0 +1,29 @@
+require "mkmf"
+
+def run(command)
+  puts ">> #{command}"
+  unless system(command)
+    raise "Command failed"
+  end
+end
+
+def inreplace(file, pattern, replacement)
+  contents = File.read(file)
+  File.write(file, contents.gsub(pattern, replacement))
+end
+
+arch = RbConfig::CONFIG["arch"]
+puts "Arch: #{arch}"
+
+scs = File.expand_path("../../vendor/scs", __dir__)
+Dir.chdir(scs) do
+  case arch
+  when /mingw/
+    inreplace("scs.mk", "USE_LAPACK = 1", "USE_LAPACK = 0")
+    run "ridk exec make"
+  else
+    run "make"
+  end
+end
+
+File.write("Makefile", dummy_makefile("scs").join)

data/lib/scs.rb

@@ -0,0 +1,17 @@
+# stdlib
+require "fiddle/import"
+
+# modules
+require "scs/solver"
+require "scs/version"
+
+module SCS
+  class Error < StandardError; end
+
+  def self.lib_version
+    FFI::Direct.scs_version.to_s
+  end
+
+  # friendlier error message
+  autoload :FFI, "scs/ffi"
+end

data/lib/scs/ffi.rb

@@ -0,0 +1,117 @@
+module SCS
+  module FFI
+    module Direct
+      def self.lib_name
+        "libscsdir"
+      end
+    end
+
+    module Indirect
+      def self.lib_name
+        "libscsindir"
+      end
+    end
+
+    ext =
+      if Gem.win_platform?
+        "dll"
+      elsif RbConfig::CONFIG["host_os"] =~ /darwin/i
+        "dylib"
+      else
+        "so"
+      end
+
+    [Direct, Indirect].each do |m|
+      m.module_eval do
+        extend Fiddle::Importer
+
+        dlload File.expand_path("../../vendor/scs/out/#{lib_name}.#{ext}", __dir__)
+
+        extern "size_t scs_sizeof_int(void)"
+        extern "size_t scs_sizeof_float(void)"
+
+        # TODO support other sizes
+        raise Error, "Unsupported int size" if scs_sizeof_int != 4
+        raise Error, "Unsupported float size" if scs_sizeof_float != 8
+
+        typealias "scs_float", "double"
+        typealias "scs_int", "int"
+
+        m::Data = struct [
+          "scs_int m",
+          "scs_int n",
+          "ScsMatrix *a",
+          "scs_float *b",
+          "scs_float *c",
+          "ScsSettings *stgs"
+        ]
+
+        m::Cone = struct [
+          "scs_int f",
+          "scs_int l",
+          "scs_int *q",
+          "scs_int qsize",
+          "scs_int *s",
+          "scs_int ssize",
+          "scs_int ep",
+          "scs_int ed",
+          "scs_float *p",
+          "scs_int psize",
+        ]
+
+        m::Solution = struct [
+          "scs_float *x",
+          "scs_float *y",
+          "scs_float *s"
+        ]
+
+        m::Info = struct [
+          "scs_int iter",
+          "char status[32]",
+          "scs_int status_val",
+          "scs_float pobj",
+          "scs_float dobj",
+          "scs_float res_pri",
+          "scs_float res_dual",
+          "scs_float res_infeas",
+          "scs_float res_unbdd",
+          "scs_float rel_gap",
+          "scs_float setup_time",
+          "scs_float solve_time"
+        ]
+
+        m::Settings = struct [
+          "scs_int normalize",
+          "scs_float scale",
+          "scs_float rho_x",
+          "scs_int max_iters",
+          "scs_float eps",
+          "scs_float alpha",
+          "scs_float cg_rate",
+          "scs_int verbose",
+          "scs_int warm_start",
+          "scs_int acceleration_lookback",
+          "const char* write_data_filename"
+        ]
+
+        m::Matrix = struct [
+          "scs_float *x",
+          "scs_int *i",
+          "scs_int *p",
+          "scs_int m",
+          "scs_int n"
+        ]
+
+        # scs.h
+        extern "ScsWork *scs_init(const ScsData *d, const ScsCone *k, ScsInfo *info)"
+        extern "scs_int scs_solve(ScsWork *w, const ScsData *d, const ScsCone *k, ScsSolution *sol, ScsInfo *info)"
+        extern "void scs_finish(ScsWork *w)"
+        extern "scs_int scs(const ScsData *d, const ScsCone *k, ScsSolution *sol, ScsInfo *info)"
+        extern "const char *scs_version(void)"
+
+        # utils.h
+        extern "void scs_set_default_settings(ScsData *d)"
+      end
+    end
+  end
+end

data/lib/scs/solver.rb

@@ -0,0 +1,173 @@
+module SCS
+  class Solver
+    def initialize(indirect: false)
+      @ffi = indirect ? FFI::Indirect : FFI::Direct
+    end
+
+    def solve(data, cone, **settings)
+      cdata = create_data(data)
+      set_settings(cdata, settings)
+      ccone = create_cone(cone)
+
+      solution = calloc(ffi::Solution.size) # alloc clear memory
+      info = ffi::Info.malloc
+
+      ffi.scs(cdata, ccone, solution, info)
+
+      solution = ffi::Solution.new(solution)
+      x = read_float_array(solution.x, cdata.n)
+      y = read_float_array(solution.y, cdata.m)
+      s = read_float_array(solution.s, cdata.m)
+
+      {
+        x: x,
+        y: y,
+        s: s,
+        iter: info.iter,
+        status: read_string(info.status),
+        status_val: info.status_val,
+        pobj: info.pobj,
+        dobj: info.dobj,
+        res_pri: info.res_pri,
+        res_dual: info.res_dual,
+        res_infeas: info.res_infeas,
+        res_unbdd: info.res_unbdd,
+        rel_gap: info.rel_gap,
+        setup_time: info.setup_time,
+        solve_time: info.solve_time
+      }
+    end
+
+    private
+
+    def check_result(ret)
+      raise Error, "Error code #{ret}" if ret != 0
+    end
+
+    def float_array(arr)
+      # SCS float = double
+      Fiddle::Pointer[arr.to_a.pack("d*")]
+    end
+
+    def read_float_array(ptr, size)
+      # SCS float = double
+      ptr[0, size * Fiddle::SIZEOF_DOUBLE].unpack("d*")
+    end
+
+    def int_array(arr)
+      # SCS int = int
+      Fiddle::Pointer[arr.to_a.pack("i!*")]
+    end
+
+    def read_string(char_ptr)
+      idx = char_ptr.index { |v| v == 0 }
+      char_ptr[0, idx].map(&:chr).join
+    end
+
+    # TODO add support sparse matrices
+    def csc_matrix(mtx, upper: false)
+      mtx = mtx.to_a
+
+      m, n = shape(mtx)
+
+      cx = []
+      ci = []
+      cp = []
+
+      # CSC format
+      # https://www.gormanalysis.com/blog/sparse-matrix-storage-formats/
+      cp << 0
+      n.times do |j|
+        mtx.each_with_index do |row, i|
+          if row[j] != 0 && (!upper || i <= j)
+            cx << row[j]
+            ci << i
+          end
+        end
+        # cumulative column values
+        cp << cx.size
+      end
+
+      # construct matrix
+      matrix = ffi::Matrix.malloc
+      matrix.x = float_array(cx)
+      matrix.i = int_array(ci)
+      matrix.p = int_array(cp)
+      matrix.m = m
+      matrix.n = n
+      matrix
+    end
+
+    def shape(a)
+      if defined?(Matrix) && a.is_a?(Matrix)
+        [a.row_count, a.column_count]
+      elsif defined?(Numo::NArray) && a.is_a?(Numo::NArray)
+        a.shape
+      else
+        [a.size, a.first.size]
+      end
+    end
+
+    def create_data(data)
+      m, n = shape(data[:a])
+      cdata = ffi::Data.malloc
+      cdata.m = m
+      cdata.n = n
+      cdata.a = csc_matrix(data[:a])
+      cdata.b = float_array(data[:b])
+      cdata.c = float_array(data[:c])
+      cdata
+    end
+
+    def create_cone(cone)
+      ccone = ffi::Cone.malloc
+      ccone.f = cone[:f].to_i
+      ccone.l = cone[:l].to_i
+      ccone.q = int_array(cone[:q])
+      ccone.qsize = cone[:q].to_a.size
+      ccone.s = int_array(cone[:s])
+      ccone.ssize = cone[:s].to_a.size
+      ccone.ep = cone[:ep].to_i
+      ccone.ed = cone[:ed].to_i
+      ccone.p = float_array(cone[:p])
+      ccone.psize = cone[:p].to_a.size
+      ccone
+    end
+
+    def set_settings(data, settings)
+      set = ffi::Settings.malloc
+      data.stgs = set
+      ffi.scs_set_default_settings(data)
+
+      # hack for setting members with []=
+      # safer than send("#{k}=", v)
+      entity = set.to_ptr
+      settings.each do |k, v|
+        entity[k.to_s] = settings_value(v)
+      end
+
+      set
+    end
+
+    # handle booleans
+    def settings_value(v)
+      case v
+      when true
+        1
+      when false
+        0
+      else
+        v
+      end
+    end
+
+    # alloc clear memory
+    def calloc(size)
+      Fiddle::Pointer["\x00" * size]
+    end
+
+    def ffi
+      @ffi
+    end
+  end
+end