scs 0.3.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: db74c6ffd6696e799a18d2f5d02f5b753020a2535e539cdd26abac388f1ea046
-  data.tar.gz: f7d5b3b98b58d812fb923193303b7f0bfcf7cb2972de2ae34a392fb9f4a5bd40
+  metadata.gz: 2afa78c52786f5325f64a76edb263b4d30dabab7b15a9415375ed57af861669c
+  data.tar.gz: ae105845b96b30fab4a24bdf3eb2c1f80db7b12d635716ac3c4acfdb17930783
 SHA512:
-  metadata.gz: cf7a4948ba7a21865142a421da3e683904951faf7e602d429722cf05bdbae559dcc15484e6cb4afa6bf683ecf681757370bfa3fa7b01dab6620b300462eea703
-  data.tar.gz: 493da1d4fbe2fdb7180fffad3599137500d437b082d788365bf828dd8845469b3bf0d63863ea467c013cc2f874c5b04ab935c7129d45b1c890278dda7ad21039
+  metadata.gz: b8bc74c496d1661b5f14e6da33c79987502d4c320c6789e4cd2d7a4bf118a8800978dc0cd0989f2f9d38978a9d27e14c37d47f8b6bb63ced36af97fee753f5e0
+  data.tar.gz: 5282b6cd3e7f7ed98423ef61eabb1275ce17bdb7b497fab9f7537c53cf7be154d3f1029a170c2c6562bb35780ebceca075e8ca12cd81af163bb7824bb2e91a27

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 0.4.0 (2022-07-06)
+
+- Updated SCS to 3.2.0
+- Added `Matrix` class
+- Dropped support for Ruby < 2.7
+
 ## 0.3.2 (2022-01-17)
 
 - Updated SCS to 3.1.1

data/README.md

@@ -18,11 +18,16 @@ If installation fails, you may need to install [dependencies](#dependencies).
 
 ## Getting Started
 
-Prep the problem
+Prep the problem, like [this one](https://www.cvxgrp.org/scs/examples/python/basic_qp.html)
 
 ```ruby
-data = {a: [[1], [-1]], b: [1, 0], c: [-1]}
-cone = {q: [], l: 2}
+data = {
+  p: SCS::Matrix.from_dense([[3, -1], [-1, 2]]),
+  a: SCS::Matrix.from_dense([[-1, 1], [1, 0], [0, 1]]),
+  b: [-1, 0.3, -0.5],
+  c: [-1, -1]
+}
+cone = {z: 1, l: 2}
 ```
 
 And solve it
@@ -32,12 +37,36 @@ solver = SCS::Solver.new
 solver.solve(data, cone)
 ```
 
+## Data
+
+Matrices can be a sparse matrix
+
+```ruby
+a = SCS::Matrix.new(3, 2)
+a[0, 0] = 1
+a[1, 0] = 2
+# or
+SCS::Matrix.from_dense([[1, 0], [2, 0], [0, 0]])
+```
+
+Arrays can be Ruby arrays
+
+```ruby
+[1, 2, 3]
+```
+
+Or Numo arrays
+
+```ruby
+Numo::NArray.cast([1, 2, 3])
+```
+
 ## Settings
 
 Default values shown
 
 ```ruby
-solver.solve(data, cone, {
+solver.solve(data, cone,
   normalize: true,            # heuristic data rescaling
   scale: 0.1,                 # if normalized, rescales by this factor
   adaptive_scale: true,       # heuristically adapt dual scale through the solve
@@ -54,7 +83,7 @@ solver.solve(data, cone, {
   acceleration_interval: 10,  # iterations to run Anderson acceleration
   write_data_filename: nil,   # filename to write data if set
   log_csv_filename: nil       # write csv logs of various quantities
-})
+)
 ```
 
 ## Direct vs Indirect

data/lib/scs/matrix.rb

@@ -0,0 +1,72 @@
+module SCS
+  class Matrix
+    attr_reader :m, :n
+
+    def initialize(m, n)
+      @m = m
+      @n = n
+      @data = {}
+    end
+
+    def []=(row_index, column_index, value)
+      raise IndexError, "row index out of bounds" if row_index < 0 || row_index >= @m
+      raise IndexError, "column index out of bounds" if column_index < 0 || column_index >= @n
+      # dictionary of keys, optimized for converting to CSC
+      # TODO try COO for performance
+      if value == 0
+        (@data[column_index] ||= {}).delete(row_index)
+      else
+        (@data[column_index] ||= {})[row_index] = value
+      end
+    end
+
+    def to_csc
+      cx = []
+      ci = []
+      cp = []
+
+      # CSC format
+      # https://www.gormanalysis.com/blog/sparse-matrix-storage-formats/
+      cp << 0
+      n.times do |j|
+        (@data[j] || {}).sort_by { |k, v| k }.each do |k, v|
+          cx << v
+          ci << k
+        end
+        # cumulative column values
+        cp << cx.size
+      end
+
+      {
+        start: cp,
+        index: ci,
+        value: cx
+      }
+    end
+
+    # private, for tests
+    def nnz
+      @data.sum { |_, v| v.count }
+    end
+
+    def initialize_copy(other)
+      super
+      @data = @data.transform_values(&:dup)
+    end
+
+    def self.from_dense(data)
+      data = data.to_a
+      m = data.size
+      n = m > 0 ? data.first.size : 0
+
+      mtx = Matrix.new(m, n)
+      data.each_with_index do |row, i|
+        raise ArgumentError, "row has different number of columns" if row.size != n
+        row.each_with_index do |v, j|
+          mtx[i, j] = v if v != 0
+        end
+      end
+      mtx
+    end
+  end
+end

data/lib/scs/solver.rb

@@ -73,42 +73,35 @@ module SCS
       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
+      mtx = Matrix.from_dense(mtx) unless mtx.is_a?(Matrix)
+
+      if upper
+        # TODO improve performance
+        mtx = mtx.dup
+        mtx.m.times do |i|
+          mtx.n.times do |j|
+            mtx[i, j] = 0 if i > j
           end
         end
-        # cumulative column values
-        cp << cx.size
       end
 
+      csc = mtx.to_csc
+
       # 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.x = float_array(csc[:value])
+      matrix.i = int_array(csc[:index])
+      matrix.p = int_array(csc[:start])
+      matrix.m = mtx.m
+      matrix.n = mtx.n
       matrix
     end
 
     def shape(a)
-      if defined?(Matrix) && a.is_a?(Matrix)
+      if a.is_a?(Matrix)
+        [a.m, a.n]
+      elsif defined?(::Matrix) && a.is_a?(::Matrix)
         [a.row_count, a.column_count]
       elsif defined?(Numo::NArray) && a.is_a?(Numo::NArray)
         a.shape
@@ -126,7 +119,7 @@ module SCS
 
       if data[:p]
         raise ArgumentError, "Bad p shape" if shape(data[:p]) != [n, n]
-        cdata.p = csc_matrix(data[:p])
+        cdata.p = csc_matrix(data[:p], upper: true)
       end
 
       raise ArgumentError, "Bad b size" if data[:b].to_a.size != m

data/lib/scs/version.rb

@@ -1,3 +1,3 @@
 module SCS
-  VERSION = "0.3.2"
+  VERSION = "0.4.0"
 end

data/lib/scs.rb

@@ -2,6 +2,7 @@
 require "fiddle/import"
 
 # modules
+require "scs/matrix"
 require "scs/solver"
 require "scs/version"
 

data/vendor/scs/CITATION.cff

@@ -10,7 +10,7 @@ authors:
 - family-names: "Boyd"
   given-names: "Stephen"
 title: "SCS: Spltting Conic Solver"
-version: 3.1.1
+version: 3.2.0
 date-released: 2021
 url: "https://github.com/cvxgrp/scs"
 

data/vendor/scs/CMakeLists.txt

@@ -5,7 +5,7 @@ cmake_minimum_required(VERSION 3.5)
 
 project(scs
   LANGUAGES C
-  VERSION 3.1.1)
+  VERSION 3.2.0)
 
 # Defines the CMAKE_INSTALL_LIBDIR, CMAKE_INSTALL_BINDIR and many other useful macros.
 # See https://cmake.org/cmake/help/latest/module/GNUInstallDirs.html
@@ -110,7 +110,7 @@ option(DLONG "Use long integers (64bit) for indexing" OFF)
 message(STATUS "Long integers (64bit) are ${DLONG}")
 
 
-set(COMPILER_OPTS "-DUSE_LAPACK -DCOPYAMATRIX -DCTRLC")
+set(COMPILER_OPTS "-DUSE_LAPACK -DCTRLC")
 
 # Primitive types
 if(SFLOAT)

data/vendor/scs/README.md

@@ -8,6 +8,8 @@
 
 
 SCS (`splitting conic solver`) is a numerical optimization package for solving
-large-scale convex cone problems. The current version is `3.1.1`.
+large-scale convex cone problems. The current version is `3.2.0`.
 
 The full documentation is available [here](https://www.cvxgrp.org/scs/).
+
+If you wish to cite SCS please cite the papers listed [here](https://www.cvxgrp.org/scs/citing).

data/vendor/scs/include/cones.h

@@ -18,14 +18,14 @@ struct SCS_CONE_WORK {
    * cone boundaries, boundaries[0] is starting index for cones of size larger
    * than 1
    */
-  const ScsCone *k; /* original cone information */
+  ScsCone *k; /* original cone information */
   scs_int *cone_boundaries;
   scs_int cone_boundaries_len;
   scs_int scaled_cones; /* boolean, whether the cones have been scaled */
   scs_float *s;         /* used for Moreau decomposition in projection */
   scs_int m;            /* total length of cone */
   /* box cone quantities */
-  scs_float *bl, *bu, box_t_warm_start;
+  scs_float box_t_warm_start;
 #ifdef USE_LAPACK
   /* workspace for eigenvector decompositions: */
   scs_float *Xs, *Z, *e, *work;
@@ -33,7 +33,9 @@ struct SCS_CONE_WORK {
 #endif
 };
 
-ScsConeWork *SCS(init_cone)(const ScsCone *k, scs_int m);
+void SCS(free_cone)(ScsCone *k);
+void SCS(deep_copy_cone)(ScsCone *dest, const ScsCone *src);
+ScsConeWork *SCS(init_cone)(ScsCone *k, scs_int m);
 char *SCS(get_cone_header)(const ScsCone *k);
 scs_int SCS(validate_cones)(const ScsData *d, const ScsCone *k);
 scs_int SCS(proj_dual_cone)(scs_float *x, ScsConeWork *c, ScsScaling *scal,

data/vendor/scs/include/glbopts.h

@@ -14,7 +14,7 @@ extern "C" {
 
 /* SCS VERSION NUMBER ----------------------------------------------    */
 /* string literals automatically null-terminated */
-#define SCS_VERSION ("3.1.1")
+#define SCS_VERSION ("3.2.0")
 
 /* verbosity level */
 #ifndef VERBOSITY
@@ -49,6 +49,9 @@ extern "C" {
 #define scs_realloc mxRealloc
 #elif defined PYTHON
 #include <Python.h>
+/* see:
+ * https://cython-users.narkive.com/jRjjs3sK/reacquire-gil-for-printing-in-wrapped-c-library
+ */
 #define scs_printf(...)                                                        \
   {                                                                            \
     PyGILState_STATE gilstate = PyGILState_Ensure();                           \
@@ -60,8 +63,6 @@ extern "C" {
 #define scs_malloc PyMem_RawMalloc
 #define scs_realloc PyMem_RawRealloc
 #define scs_calloc PyMem_RawCalloc
-/* only for SuiteSparse + python */
-#define _scs_printf PySys_WriteStdout
 #else
 #define scs_free PyMem_Free
 #define scs_malloc PyMem_Malloc
@@ -107,8 +108,6 @@ static inline void *scs_calloc(size_t count, size_t size) {
 #endif
 #endif
 
-#define SCS_NULL 0
-
 #ifndef MAX
 #define MAX(a, b) (((a) > (b)) ? (a) : (b))
 #endif

data/vendor/scs/include/normalize.h

@@ -8,6 +8,7 @@ extern "C" {
 #include "glbopts.h"
 #include "scs_work.h"
 
+void SCS(normalize_b_c)(ScsScaling *scal, scs_float *b, scs_float *c);
 void SCS(normalize_sol)(ScsScaling *scal, ScsSolution *sol);
 void SCS(un_normalize_sol)(ScsScaling *scal, ScsSolution *sol);
 void SCS(un_normalize_primal)(ScsScaling *scal, scs_float *r);

data/vendor/scs/include/rw.h

@@ -13,9 +13,9 @@ void SCS(write_data)(const ScsData *d, const ScsCone *k,
                      const ScsSettings *stgs);
 scs_int SCS(read_data)(const char *filename, ScsData **d, ScsCone **k,
                        ScsSettings **stgs);
-void SCS(log_data_to_csv)(const ScsData *d, const ScsCone *k,
-                          const ScsSettings *stgs, const ScsWork *w,
-                          scs_int iter, SCS(timer) * solve_timer);
+void SCS(log_data_to_csv)(const ScsCone *k, const ScsSettings *stgs,
+                          const ScsWork *w, scs_int iter,
+                          SCS(timer) * solve_timer);
 
 #ifdef __cplusplus
 }

data/vendor/scs/include/scs.h

@@ -11,6 +11,8 @@ extern "C" {
 /* Contains definitions of primitive types `scs_int` and `scs_float`. */
 #include "scs_types.h"
 
+#define SCS_NULL 0 /* NULL type */
+
 /* The following abstract structs are implemented later. */
 
 /** Struct containing acceleration workspace. Implemented by acceleration. */
@@ -116,11 +118,11 @@ typedef struct {
   scs_float *bl;
   /** Total length of box cone (includes scale `t`). */
   scs_int bsize;
-  /** Array of second-order cone constraints. */
+  /** Array of second-order cone constraints, `len(q) = qsize`. */
   scs_int *q;
   /** Length of second-order cone array `q`. */
   scs_int qsize;
-  /** Array of semidefinite cone constraints. */
+  /** Array of semidefinite cone constraints, `len(s) = ssize`. */
   scs_int *s;
   /** Length of semidefinite constraints array `s`. */
   scs_int ssize;
@@ -129,7 +131,7 @@ typedef struct {
   /** Number of dual exponential cone triples. */
   scs_int ed;
   /** Array of power cone params, must be in `[-1, 1]`, negative values are
-   * interpreted as specifying the dual cone. */
+   * interpreted as specifying the dual cone, `len(p) = psize ` */
   scs_float *p;
   /** Number of (primal and dual) power cone triples. */
   scs_int psize;
@@ -205,7 +207,9 @@ typedef struct {
 /**
  * Initialize SCS and allocate memory.
  *
- * All the inputs must be already allocated in memory before calling.
+ * All the inputs must be already allocated in memory before calling. After
+ * this function returns then the memory associated with `d`, `k`, and `stgs`
+ * can be freed as SCS maintains deep copies of these internally.
  *
  * It performs:
  * - data and settings validation
@@ -213,26 +217,45 @@ typedef struct {
  * - automatic parameters tuning (if enabled)
  * - setup linear system solver:
  *      - direct solver: KKT matrix factorization is performed here
- *      - indirect solver: KKT matrix preconditioning is performed here
- * - solve the linear system for the `r` vector in the paper.
+ *      - indirect solver: KKT matrix preconditioning is performed here.
  *
  *
- * @param  d 		 Problem data.
- * @param  k 		 Cone data.
- * @param  stgs  SCS solver settings.
- * @return       Solver work struct.
+ * @param  d      Problem data.
+ * @param  k      Cone data.
+ * @param  stgs   SCS solve settings.
+ * @return        Solver workspace.
  */
 ScsWork *scs_init(const ScsData *d, const ScsCone *k, const ScsSettings *stgs);
 
+/**
+ * Update the `b` vector, `c` vector, or both, before another solve call.
+ *
+ * After a solve we can reuse the SCS workspace in another solve if the only
+ * problem data that has changed are the `b` and `c` vectors.
+ *
+ * @param  w            SCS workspace from scs_init (modified in-place).
+ * @param  b            New `b` vector (can be `SCS_NULL` if unchanged).
+ * @param  c            New `c` vector (can be `SCS_NULL` if unchanged).
+ *
+ * @return              0 if update successful.
+ */
+scs_int scs_update(ScsWork *w, scs_float *b, scs_float *c);
+
 /**
  * Solve quadratic cone program initialized by scs_init.
  *
- * @param  w     Workspace allocated by init.
- * @param  sol 	 Solver solution struct, will contain solution at termination.
- * @param  info  Solver info reporting.
+ * @param  w            Workspace allocated by scs_init.
+ * @param  sol          Solution will be stored here. If members `x`, `y`, `s`
+ *                      are NULL then SCS will allocate memory for them which
+ *                      must be freed by the caller.
+ * @param  info         Information about the solve will be stored here.
+ * @param  warm_start   Whether to use the entries of `sol` as warm-start for
+ *                      the solve.
+ *
  * @return       Flag containing problem status (see \a glbopts.h).
  */
-scs_int scs_solve(ScsWork *w, ScsSolution *sol, ScsInfo *info);
+scs_int scs_solve(ScsWork *w, ScsSolution *sol, ScsInfo *info,
+                  scs_int warm_start);
 
 /**
  * Clean up allocated SCS workspace.
@@ -246,13 +269,13 @@ void scs_finish(ScsWork *w);
  *
  * All the inputs must already be allocated in memory before calling.
  *
- * @param  d 		 Problem data.
- * @param  k 		 Cone data.
- * @param  stgs  SCS solver settings.
- * @param  sol   Solution will be stored here. If members `x`, `y`, `s` are
- *               NULL then SCS will allocate memory for them.
- * @param  info  Information about the solve will be stored here.
- * @return       Flag that determines solve type (see \a glbopts.h).
+ * @param  d      Problem data.
+ * @param  k      Cone data.
+ * @param  stgs   SCS solver settings.
+ * @param  sol    Solution will be stored here. If members `x`, `y`, `s` are
+ *                NULL then SCS will allocate memory for them.
+ * @param  info   Information about the solve will be stored here.
+ * @return        Flag containing problem status (see \a glbopts.h).
  */
 scs_int scs(const ScsData *d, const ScsCone *k, const ScsSettings *stgs,
             ScsSolution *sol, ScsInfo *info);
@@ -260,7 +283,7 @@ scs_int scs(const ScsData *d, const ScsCone *k, const ScsSettings *stgs,
 /**
  * Helper function to set all settings to default values (see \a glbopts.h).
  *
- * @param  stgs  Settings struct that will be populated.
+ * @param  stgs   Settings struct that will be populated.
  */
 void scs_set_default_settings(ScsSettings *stgs);
 

data/vendor/scs/include/scs_work.h

@@ -9,6 +9,8 @@
 extern "C" {
 #endif
 
+#include "scs.h"
+
 /** Contains normalization variables. */
 typedef struct {
   scs_float *D, *E; /* for normalization */
@@ -40,10 +42,11 @@ typedef struct {
   scs_float *ax, *ax_s, *px, *aty, *ax_s_btau, *px_aty_ctau;
 } ScsResiduals;
 
-/** Workspace for SCS */
+/** Workspace for SCS. */
 struct SCS_WORK {
   /* x_prev = x from previous iteration */
-  scs_int time_limit_reached; /* set if the time-limit is reached */
+  scs_float setup_time;       /* time taken for setup phase (milliseconds) */
+  scs_int time_limit_reached; /* boolean, if the time-limit is reached */
   scs_float *u, *u_t;
   scs_float *v, *v_prev;
   scs_float *rsk;                /* rsk [ r; s; kappa ] */
@@ -51,30 +54,24 @@ struct SCS_WORK {
   scs_float *g;                  /* g = (I + M)^{-1} h */
   scs_float *lin_sys_warm_start; /* linear system warm-start (indirect only) */
   scs_float *diag_r; /* vector of R matrix diagonals (affects cone proj) */
-  AaWork *accel;     /* struct for acceleration workspace */
-  scs_float *b_orig, *c_orig;             /* original b and c vectors */
-  scs_float *b_normalized, *c_normalized; /* normalized b and c vectors */
-  scs_int m, n;                           /* A has m rows, n cols */
-  ScsMatrix *A;                           /* (possibly normalized) A matrix */
-  ScsMatrix *P;                           /* (possibly normalized) P matrix */
-  ScsLinSysWork *p;       /* struct populated by linear system solver */
-  ScsScaling *scal;       /* contains the re-scaling data */
-  ScsConeWork *cone_work; /* workspace for the cone projection step */
+  scs_float *b_orig, *c_orig; /* original unnormalized b and c vectors */
+  AaWork *accel;              /* struct for acceleration workspace */
+  ScsData *d;                 /* Problem data deep copy NORMALIZED */
+  ScsCone *k;                 /* Problem cone deep copy */
+  ScsSettings *stgs;          /* contains solver settings specified by user */
+  ScsLinSysWork *p;           /* struct populated by linear system solver */
+  ScsScaling *scal;           /* contains the re-scaling data */
+  ScsConeWork *cone_work;     /* workspace for the cone projection step */
   /* normalized and unnormalized residuals */
   ScsResiduals *r_orig, *r_normalized;
   /* track x,y,s as alg progresses, tau *not* divided out */
   ScsSolution *xys_orig, *xys_normalized;
-  /* updating scale params workspace */
+  /* Scale updating workspace */
   scs_float sum_log_scale_factor;
   scs_int last_scale_update_iter, n_log_scale_factor, scale_updates;
-  /* aa norm stat */
+  /* AA stats */
   scs_float aa_norm;
   scs_int rejected_accel_steps, accepted_accel_steps;
-  scs_float setup_time; /* time taken for setup phase (milliseconds) */
-  scs_float scale;      /* current scale parameter */
-  const ScsData *d;
-  const ScsCone *k;
-  const ScsSettings *stgs; /* contains solver settings specified by user */
 };
 
 #ifdef __cplusplus

data/vendor/scs/include/util.h

@@ -45,7 +45,9 @@ typedef struct SCS(timer) {
 void SCS(tic)(SCS(timer) * t);
 scs_float SCS(tocq)(SCS(timer) * t);
 void SCS(free_sol)(ScsSolution *sol);
-void SCS(free_data)(ScsData *d, ScsCone *k, ScsSettings *stgs);
+void SCS(deep_copy_data)(ScsData *dest, const ScsData *src);
+void SCS(deep_copy_stgs)(ScsSettings *dest, const ScsSettings *src);
+void SCS(free_data)(ScsData *d);
 
 #ifdef __cplusplus
 }