scs 0.2.1 → 0.3.1

data/vendor/scs/include/glbopts.h

@@ -12,8 +12,8 @@ extern "C" {
 #endif
 
 /* SCS VERSION NUMBER ----------------------------------------------    */
-#define SCS_VERSION \
-  ("2.1.2") /* string literals automatically null-terminated */
+#define SCS_VERSION                                                            \
+  ("3.0.0") /* string literals automatically null-terminated */
 
 /* SCS returns one of the following integers:                           */
 #define SCS_INFEASIBLE_INACCURATE (-7)
@@ -27,18 +27,28 @@ extern "C" {
 #define SCS_SOLVED (1)
 #define SCS_SOLVED_INACCURATE (2)
 
+/* verbosity level */
+#ifndef VERBOSITY
+#define VERBOSITY (0)
+#endif
+
 /* DEFAULT SOLVER PARAMETERS AND SETTINGS --------------------------    */
-#define MAX_ITERS (5000)
-#define EPS (1E-5)
+#define MAX_ITERS (100000)
+#define EPS_REL (1E-4)
+#define EPS_ABS (1E-4)
+#define EPS_INFEAS (1E-7)
 #define ALPHA (1.5)
-#define RHO_X (1E-3)
-#define SCALE (1.0)
-#define CG_RATE (2.0)
+#define RHO_X (1E-6)
+#define SCALE (0.1)
 #define VERBOSE (1)
 #define NORMALIZE (1)
 #define WARM_START (0)
 #define ACCELERATION_LOOKBACK (10)
+#define ACCELERATION_INTERVAL (10)
+#define ADAPTIVE_SCALE (1)
 #define WRITE_DATA_FILENAME (0)
+#define LOG_CSV_FILENAME (0)
+#define TIME_LIMIT_SECS (0.)
 
 /* redefine printfs and memory allocators as needed */
 #ifdef MATLAB_MEX_FILE
@@ -50,19 +60,30 @@ extern "C" {
 #define _scs_realloc mxRealloc
 #elif defined PYTHON
 #include <Python.h>
-#include <stdlib.h>
-#define scs_printf(...)                              \
-  {                                                  \
-    PyGILState_STATE gilstate = PyGILState_Ensure(); \
-    PySys_WriteStdout(__VA_ARGS__);                  \
-    PyGILState_Release(gilstate);                    \
+#define scs_printf(...)                                                        \
+  {                                                                            \
+    PyGILState_STATE gilstate = PyGILState_Ensure();                           \
+    PySys_WriteStdout(__VA_ARGS__);                                            \
+    PyGILState_Release(gilstate);                                              \
   }
-#define _scs_printf printf
-#define _scs_free free
-#define _scs_malloc malloc
-#define _scs_calloc calloc
-#define _scs_realloc realloc
-#elif (defined(USING_R))
+/* only for SuiteSparse */
+#define _scs_printf PySys_WriteStdout
+#if PY_MAJOR_VERSION >= 3
+#define _scs_free PyMem_RawFree
+#define _scs_malloc PyMem_RawMalloc
+#define _scs_realloc PyMem_RawRealloc
+#define _scs_calloc PyMem_RawCalloc
+#else
+#define _scs_free PyMem_Free
+#define _scs_malloc PyMem_Malloc
+#define _scs_realloc PyMem_Realloc
+static inline void *_scs_calloc(size_t count, size_t size) {
+  void *obj = PyMem_Malloc(count * size);
+  memset(obj, 0, count * size);
+  return obj;
+}
+#endif
+#elif defined R_LANG
 #include <R_ext/Print.h> /* Rprintf etc */
 #include <stdio.h>
 #include <stdlib.h>
@@ -86,21 +107,22 @@ extern "C" {
 #define _scs_printf scs_printf
 #endif
 
-#define scs_free(x) \
-  _scs_free(x);     \
+#define scs_free(x)                                                            \
+  _scs_free(x);                                                                \
   x = SCS_NULL
 #define scs_malloc(x) _scs_malloc(x)
 #define scs_calloc(x, y) _scs_calloc(x, y)
 #define scs_realloc(x, y) _scs_realloc(x, y)
 
 #ifdef DLONG
-#ifdef _WIN64
+/*#ifdef _WIN64
 #include <stdint.h>
 typedef int64_t scs_int;
-/* typedef long scs_int; */
 #else
 typedef long scs_int;
 #endif
+*/
+typedef long long scs_int;
 #else
 typedef int scs_int;
 #endif
@@ -153,23 +175,67 @@ typedef float scs_float;
 #endif
 #endif
 
+/* Force SCS to treat the problem as (non-homogeneous) feasible for this many */
+/* iters. This acts like a warm-start that biases towards feasibility, which */
+/* is the most common use-case */
+#define FEASIBLE_ITERS (1)
+
+/* how many iterations between heuristic residual rescaling */
+#define RESCALING_MIN_ITERS (100)
+
 #define EPS_TOL (1E-18)
 #define SAFEDIV_POS(X, Y) ((Y) < EPS_TOL ? ((X) / EPS_TOL) : (X) / (Y))
 
-#if EXTRA_VERBOSE > 0
+#if VERBOSITY > 0
 #define PRINT_INTERVAL (1)
 #define CONVERGED_INTERVAL (1)
 #else
+
 /* print summary output every this num iterations */
-#define PRINT_INTERVAL (100)
+#define PRINT_INTERVAL (250)
 /* check for convergence every this num iterations */
-#define CONVERGED_INTERVAL (20)
-#endif
-
-/* tolerance at which we declare problem indeterminate */
-#define INDETERMINATE_TOL (1e-9)
-/* maintain the iterates at this l2 norm (due to homogeneity) */
-#define ITERATE_NORM (10.)
+#define CONVERGED_INTERVAL (25)
+#endif
+
+/* maintain the iterates at L2 norm =  ITERATE_NORM * sqrt(n+m+1) */
+#define ITERATE_NORM (1.)
+
+/* Which norm to use for termination checking etc */
+/* #define NORM SCS(norm_2) */
+#define NORM SCS(norm_inf)
+
+/* Factor which is scales tau in the linear system update */
+/* Larger factors prevent tau from moving as much */
+#define TAU_FACTOR (10.)
+
+/* Anderson acceleration parameters: */
+#define AA_RELAXATION (1.0)
+#define AA_REGULARIZATION_TYPE_1 (1e-6)
+#define AA_REGULARIZATION_TYPE_2 (1e-10)
+/* Safeguarding norm factor at which we reject AA steps */
+#define AA_SAFEGUARD_FACTOR (1.)
+/* Max allowable AA weight norm */
+#define AA_MAX_WEIGHT_NORM (1e10)
+
+/* (Dual) Scale updating parameters */
+#define MAX_SCALE_VALUE (1e6)
+#define MIN_SCALE_VALUE (1e-6)
+#define SCALE_NORM NORM /* what norm to use when computing the scale factor */
+
+/* CG == Conjugate gradient */
+/* Linear system tolerances, only used with indirect */
+#define CG_BEST_TOL (1e-12)
+/* This scales the current residuals to get the tolerance we solve the
+ * linear system to at each iteration. Lower factors require more CG steps
+ * but give better accuracy */
+#define CG_TOL_FACTOR (0.2)
+
+/* norm to use when deciding CG convergence */
+#ifndef CG_NORM
+#define CG_NORM SCS(norm_inf)
+#endif
+/* cg tol ~ O(1/k^(CG_RATE)) */
+#define CG_RATE (1.5)
 
 #ifdef __cplusplus
 }

data/vendor/scs/include/linalg.h

@@ -5,15 +5,13 @@
 extern "C" {
 #endif
 
-#include <math.h>
 #include "scs.h"
+#include <math.h>
 
-void SCS(set_as_scaled_array)(scs_float *x, const scs_float *a,
-                              const scs_float b, scs_int len);
 void SCS(scale_array)(scs_float *a, const scs_float b, scs_int len);
 scs_float SCS(dot)(const scs_float *x, const scs_float *y, scs_int len);
 scs_float SCS(norm_sq)(const scs_float *v, scs_int len);
-scs_float SCS(norm)(const scs_float *v, scs_int len);
+scs_float SCS(norm_2)(const scs_float *v, scs_int len);
 scs_float SCS(norm_inf)(const scs_float *a, scs_int l);
 void SCS(add_scaled_array)(scs_float *a, const scs_float *b, scs_int n,
                            const scs_float sc);

data/vendor/scs/include/linsys.h

@@ -7,55 +7,69 @@ extern "C" {
 
 #include "scs.h"
 
-/* YOUR LINEAR SYSTEM SOLVER MUST IMPLEMENT THESE METHODS AND SCS_LIN_SYS_WORK
- * STRUCT */
+/* This is the API that any new linear system solver must implement */
 
-/* initialize ScsLinSysWork structure and perform any necessary preprocessing */
-ScsLinSysWork *SCS(init_lin_sys_work)(const ScsMatrix *A,
-                                      const ScsSettings *stgs);
-/* solves [d->RHO_X * I  A' ; A  -I] x = b for x, stores result in b, s contains
- * warm-start, iter is current scs iteration count */
-scs_int SCS(solve_lin_sys)(const ScsMatrix *A, const ScsSettings *stgs,
-                           ScsLinSysWork *p, scs_float *b, const scs_float *s,
-                           scs_int iter);
-/* frees ScsLinSysWork structure and allocated memory in ScsLinSysWork */
-void SCS(free_lin_sys_work)(ScsLinSysWork *p);
+/* Struct containing linear system workspace. Implemented by linear solver. */
+/* This typedef is in scs.h */
+/* typedef struct SCS_LIN_SYS_WORK ScsLinSysWork; */
 
-/* forms y += A'*x */
-void SCS(accum_by_atrans)(const ScsMatrix *A, ScsLinSysWork *p,
-                          const scs_float *x, scs_float *y);
-/* forms y += A*x */
-void SCS(accum_by_a)(const ScsMatrix *A, ScsLinSysWork *p, const scs_float *x,
-                     scs_float *y);
+/**
+ * Initialize `ScsLinSysWork` structure and perform any necessary preprocessing.
+ *
+ *  @param  A          A data matrix.
+ *  @param  P          P data matrix.
+ *  @param  rho_y_vec  `rho_y > 0` diagonal entries.
+ *  @param  rho_x      `rho_x > 0` float.
+ *  @return            Linear system solver workspace.
+ *
+ */
+ScsLinSysWork *SCS(init_lin_sys_work)(const ScsMatrix *A, const ScsMatrix *P,
+                                      scs_float *rho_y_vec, scs_float rho_x);
 
-/* returns negative num if input data is invalid */
-scs_int SCS(validate_lin_sys)(const ScsMatrix *A);
+/**
+ * Frees `ScsLinSysWork` structure and associated allocated memory.
+ *
+ *  @param  w    Linear system private workspace.
+ */
+void SCS(free_lin_sys_work)(ScsLinSysWork *w);
 
-/* returns string describing method, can return null, if not null free will be
- * called on output */
-char *SCS(get_lin_sys_method)(const ScsMatrix *A, const ScsSettings *stgs);
-/* returns string containing summary information about linear system solves, can
- * return null, if not null free will be called on output */
-char *SCS(get_lin_sys_summary)(ScsLinSysWork *p, const ScsInfo *info);
+/**
+ * Solves the linear system required by SCS at each iteration:
+ * \f[
+ *    \begin{bmatrix}
+ *    (\rho_x I + P) & A^\top \\
+ *     A   &  -\mathrm{diag}(\rho_y) \\
+ *    \end{bmatrix} x = b
+ *  \f]
+ *
+ *  for `x`. Overwrites `b` with result.
+ *
+ *  @param  w    Linear system private workspace.
+ *  @param  b    Right hand side, contains solution at the end.
+ *  @param  s    Contains warm-start (may be NULL).
+ *  @param  tol  Tolerance required for the system solve.
+ *  @return status < 0 indicates failure.
+ *
+ */
+scs_int SCS(solve_lin_sys)(ScsLinSysWork *w, scs_float *b, const scs_float *s,
+                           scs_float tol);
+/**
+ *  Update the linsys workspace when `rho_y_vec` is changed. For example, a
+ *  direct method for solving the linear system might need to update the
+ *  factorization of the matrix.
+ *
+ *  @param  w          Linear system private workspace.
+ *  @param  rho_y_vec  `rho_y` diagonal entries.
+ *
+ */
+void SCS(update_lin_sys_rho_y_vec)(ScsLinSysWork *w, scs_float *rho_y_vec);
 
-/* Normalization routines, used if d->NORMALIZE is true */
-/* normalizes A matrix, sets w->E and w->D diagonal scaling matrices, Anew =
- * d->SCALE * (D^-1)*A*(E^-1) (different to paper which is D*A*E)
- * D and E must be all positive entries, D must satisfy cone boundaries
- * must set (w->mean_norm_row_a = mean of norms of rows of normalized A) THEN
- * scale
- * resulting A by d->SCALE */
-void SCS(normalize_a)(ScsMatrix *A, const ScsSettings *stgs, const ScsCone *k,
-                      ScsScaling *scal);
-/* unnormalizes A matrix, unnormalizes by w->D and w->E and d->SCALE */
-void SCS(un_normalize_a)(ScsMatrix *A, const ScsSettings *stgs,
-                         const ScsScaling *scal);
-/* to free the memory allocated in ScsMatrix */
-void SCS(free_a_matrix)(ScsMatrix *A);
-
-/* copies A (instead of in-place normalization), returns 0 for failure,
- * allocates memory for dstp	*/
-scs_int SCS(copy_a_matrix)(ScsMatrix **dstp, const ScsMatrix *src);
+/**
+ * Name of the linear solver.
+ *
+ * @return name of method.
+ */
+const char *SCS(get_lin_sys_method)(void);
 
 #ifdef __cplusplus
 }

data/vendor/scs/include/normalize.h

@@ -7,10 +7,10 @@ extern "C" {
 
 #include "scs.h"
 
-void SCS(normalize_b_c)(ScsWork *w);
-void SCS(calc_scaled_resids)(ScsWork *w, ScsResiduals *r);
-void SCS(normalize_warm_start)(ScsWork *w);
+void SCS(normalize_sol)(ScsWork *w, ScsSolution *sol);
 void SCS(un_normalize_sol)(ScsWork *w, ScsSolution *sol);
+void SCS(un_normalize_primal)(ScsWork *w, scs_float *r);
+void SCS(un_normalize_dual)(ScsWork *w, scs_float *r);
 
 #ifdef __cplusplus
 }

data/vendor/scs/include/rw.h

@@ -7,9 +7,15 @@ extern "C" {
 
 #include "glbopts.h"
 #include "scs.h"
+#include "util.h"
 
-void SCS(write_data)(const ScsData *d, const ScsCone *k);
-scs_int SCS(read_data)(const char * filename, ScsData **d, ScsCone **k);
+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);
 
 #ifdef __cplusplus
 }