scs 0.2.2 → 0.3.2

data/vendor/scs/include/aa.h

@@ -5,50 +5,94 @@
 extern "C" {
 #endif
 
+#include "glbopts.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include "glbopts.h"
 
 typedef scs_float aa_float;
 typedef scs_int aa_int;
 
 typedef struct ACCEL_WORK AaWork;
 
-/* Initialize Anderson Acceleration, allocates memory.
+/**
+ * Initialize Anderson Acceleration, allocates memory.
+ *
+ * @param dim               the dimension of the variable for AA
+ * @param mem               the memory (number of past iterations used) for AA
+ * @param type1             if True use type 1 AA, otherwise use type 2
+ * @param regularization    type-I and type-II different, for type-I: 1e-8 works
+ *                          well, type-II: more stable can use 1e-12 often
+ * @param relaxation        float in [0,2], mixing parameter (1.0 is vanilla)
+ * @param safeguard_factor  factor that controls safeguarding checks
+ *                          larger is more aggressive but less stable
+ * @param max_weight_norm   float, maximum norm of AA weights
+ * @param verbosity         if greater than 0 prints out various info
+ *
+ * @return pointer to AA workspace
+ *
+ */
+AaWork *aa_init(aa_int dim, aa_int mem, aa_int type1, aa_float regularization,
+                aa_float relaxation, aa_float safeguard_factor,
+                aa_float max_weight_norm, aa_int verbosity);
+/**
+ * Apply Anderson Acceleration. The usage pattern should be as follows:
+ *
+ * - for i = 0 .. N:
+ *    -  if (i > 0): aa_apply(x, x_prev, a)
+ *    -  x_prev = x.copy()
+ *    -  x = F(x)
+ *    -  aa_safeguard(x, x_prev, a)  // optional but helps stability
+ *
+ *  Here F is the map we are trying to find the fixed point for. We put the AA
+ *  before the map so that any properties of the map are maintained at the end.
+ *  Eg if the map contains a projection onto a set then the output is guaranteed
+ *  to be in the set.
+ *
  *
- * Args:
- *  dim: the dimension of the variable for aa
- *  aa_mem: the memory (number of past iterations used) for aa
- *  type1: bool, if True use type 1 aa, otherwise use type 2
+ * @param f   output of map at current iteration, overwritten with AA output
+ * @param x   input to map at current iteration
+ * @param a   workspace from aa_init
+ *
+ * @return (+ or -) norm of AA weights vector. If positive then update
+ *         was accepted and f contains new point, if negative then update was
+ *         rejected and f is unchanged
  *
- * Reurns:
- *  Pointer to aa workspace
  */
-AaWork *aa_init(aa_int dim, aa_int aa_mem, aa_int type1);
+aa_float aa_apply(aa_float *f, const aa_float *x, AaWork *a);
 
-/* Apply Anderson Acceleration.
+/**
+ * Apply safeguarding.
+ *
+ * This step is optional but can improve stability.
+ *
+ * @param f_new  output of map after AA step
+ * @param x_new  AA output that is input to the map
+ * @param a      workspace from aa_init
  *
- * Args:
- *  f: output of map at current iteration, overwritten with aa output at end.
- *  x: input to map at current iteration
- *  a: aa workspace from aa_init
+ * @returns 0 if AA step is accepted otherwise -1, if AA step is rejected then
+ *          this overwrites f_new and x_new with previous values
  *
- * Returns:
- *  int, a value of 0 is success, <0 is failure at which point f is unchanged
  */
-aa_int aa_apply(aa_float *f, const aa_float *x, AaWork *a);
+aa_int aa_safeguard(aa_float *f_new, aa_float *x_new, AaWork *a);
 
-/* Finish Anderson Acceleration, clears memory.
+/**
+ * Finish Anderson Acceleration, clears memory.
+ *
+ * @param a   AA workspace from aa_init
  *
- * Args:
- *  a: aa workspace from aa_init.
  */
 void aa_finish(AaWork *a);
 
-#define MAX_AA_NRM (1e4)
-
-#define MIN(a, b) (((a) < (b)) ? (a) : (b))
+/**
+ * Reset Anderson Acceleration.
+ *
+ * Resets AA as if at the first iteration, reuses original memory allocations.
+ *
+ * @param a   AA workspace from aa_init
+ *
+ */
+void aa_reset(AaWork *a);
 
 #ifdef __cplusplus
 }

data/vendor/scs/include/cones.h

@@ -8,37 +8,40 @@ extern "C" {
 #include "glbopts.h"
 #include "scs.h"
 #include "scs_blas.h"
+#include "scs_work.h"
+#include <string.h>
 
 /* private data to help cone projection step */
 struct SCS_CONE_WORK {
-  scs_float total_cone_time;
+  /*
+   * cone_boundaries will contain array of indices of rows of A corresponding to
+   * cone boundaries, boundaries[0] is starting index for cones of size larger
+   * than 1
+   */
+  const 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;
 #ifdef USE_LAPACK
   /* workspace for eigenvector decompositions: */
   scs_float *Xs, *Z, *e, *work;
-  blas_int *iwork, lwork, liwork;
+  blas_int lwork;
 #endif
 };
 
-/*
- * boundaries will contain array of indices of rows of A corresponding to
- * cone boundaries, boundaries[0] is starting index for cones of size larger
- * than 1
- * returns length of boundaries array, boundaries malloc-ed here so should be
- * freed
- */
-scs_int SCS(get_cone_boundaries)(const ScsCone *k, scs_int **boundaries);
-
-ScsConeWork *SCS(init_cone)(const ScsCone *k);
+ScsConeWork *SCS(init_cone)(const ScsCone *k, scs_int m);
 char *SCS(get_cone_header)(const ScsCone *k);
 scs_int SCS(validate_cones)(const ScsData *d, const ScsCone *k);
-
-/* pass in iter to control how accurate the cone projection
- with iteration, set iter < 0 for exact projection, warm_start contains guess
- of solution, can be SCS_NULL*/
-scs_int SCS(proj_dual_cone)(scs_float *x, const ScsCone *k, ScsConeWork *c,
-                            const scs_float *warm_start, scs_int iter);
+scs_int SCS(proj_dual_cone)(scs_float *x, ScsConeWork *c, ScsScaling *scal,
+                            scs_float *r_y);
 void SCS(finish_cone)(ScsConeWork *c);
-char *SCS(get_cone_summary)(const ScsInfo *info, ScsConeWork *c);
+void SCS(set_r_y)(const ScsConeWork *c, scs_float scale, scs_float *r_y);
+void SCS(enforce_cone_boundaries)(const ScsConeWork *c, scs_float *vec,
+                                  scs_float (*f)(const scs_float *, scs_int));
 
 #ifdef __cplusplus
 }

data/vendor/scs/include/glbopts.h

@@ -5,108 +5,93 @@
 extern "C" {
 #endif
 
+#include "scs.h"
 #include <math.h>
 
 #ifndef SCS
-#define SCS(x) scs_##x
+#define SCS(x) _scs_##x
 #endif
 
 /* SCS VERSION NUMBER ----------------------------------------------    */
-#define SCS_VERSION \
-  ("2.1.2") /* string literals automatically null-terminated */
-
-/* SCS returns one of the following integers:                           */
-#define SCS_INFEASIBLE_INACCURATE (-7)
-#define SCS_UNBOUNDED_INACCURATE (-6)
-#define SCS_SIGINT (-5)
-#define SCS_FAILED (-4)
-#define SCS_INDETERMINATE (-3)
-#define SCS_INFEASIBLE (-2) /* primal infeasible, dual unbounded   */
-#define SCS_UNBOUNDED (-1)  /* primal unbounded, dual infeasible   */
-#define SCS_UNFINISHED (0)  /* never returned, used as placeholder */
-#define SCS_SOLVED (1)
-#define SCS_SOLVED_INACCURATE (2)
+/* string literals automatically null-terminated */
+#define SCS_VERSION ("3.1.1")
+
+/* 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
 #include "mex.h"
 #define scs_printf mexPrintf
-#define _scs_free mxFree
-#define _scs_malloc mxMalloc
-#define _scs_calloc mxCalloc
-#define _scs_realloc mxRealloc
+#define scs_free mxFree
+#define scs_malloc mxMalloc
+#define scs_calloc mxCalloc
+#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))
+#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
+/* only for SuiteSparse + python */
+#define _scs_printf PySys_WriteStdout
+#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>
 #define scs_printf Rprintf
-#define _scs_free free
-#define _scs_malloc malloc
-#define _scs_calloc calloc
-#define _scs_realloc realloc
+#define scs_free free
+#define scs_malloc malloc
+#define scs_calloc calloc
+#define scs_realloc realloc
 #else
 #include <stdio.h>
 #include <stdlib.h>
 #define scs_printf printf
-#define _scs_free free
-#define _scs_malloc malloc
-#define _scs_calloc calloc
-#define _scs_realloc realloc
-#endif
-
-/* Only required for SuiteSparse compatibility: */
-#ifndef _scs_printf
-#define _scs_printf scs_printf
-#endif
-
-#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
-#include <stdint.h>
-typedef int64_t scs_int;
-/* typedef long scs_int; */
-#else
-typedef long scs_int;
-#endif
-#else
-typedef int scs_int;
+#define scs_free free
+#define scs_malloc malloc
+#define scs_calloc calloc
+#define scs_realloc realloc
 #endif
 
 #ifndef SFLOAT
-typedef double scs_float;
 #ifndef NAN
 #define NAN ((scs_float)0x7ff8000000000000)
 #endif
@@ -114,7 +99,6 @@ typedef double scs_float;
 #define INFINITY NAN
 #endif
 #else
-typedef float scs_float;
 #ifndef NAN
 #define NAN ((float)0x7fc00000)
 #endif
@@ -153,23 +137,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,20 +5,19 @@
 extern "C" {
 #endif
 
+#include "glbopts.h"
 #include <math.h>
-#include "scs.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);
 scs_float SCS(norm_diff)(const scs_float *a, const scs_float *b, scs_int l);
 scs_float SCS(norm_inf_diff)(const scs_float *a, const scs_float *b, scs_int l);
+scs_float SCS(mean)(const scs_float *x, scs_int l);
 
 #ifdef __cplusplus
 }

data/vendor/scs/include/linsys.h

@@ -5,57 +5,71 @@
 extern "C" {
 #endif
 
+#include "glbopts.h"
 #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, `m x n`.
+ *  @param  P          `P` data matrix, `n x n`.
+ *  @param  diag_r     `R > 0` diagonal entries of length `m + n`.
+ *  @return            Linear system solver workspace.
+ *
+ */
+ScsLinSysWork *SCS(init_lin_sys_work)(const ScsMatrix *A, const ScsMatrix *P,
+                                      const scs_float *diag_r);
 
-/* 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 as required by SCS at each iteration:
+ * \f[
+ *    \begin{bmatrix}
+ *    (R_x + P) & A^\top \\
+ *     A   &  -R_y \\
+ *    \end{bmatrix} x = b
+ *  \f]
+ *
+ *  for `x`, where `diag(R_x, R_y) = R`. 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 `R` 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  new_diag_r    Updated `diag_r`, diagonal entries of R.
+ *
+ */
+void SCS(update_lin_sys_diag_r)(ScsLinSysWork *w, const scs_float *new_diag_r);
 
-/* 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

@@ -5,12 +5,13 @@
 extern "C" {
 #endif
 
-#include "scs.h"
+#include "glbopts.h"
+#include "scs_work.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(un_normalize_sol)(ScsWork *w, ScsSolution *sol);
+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);
+void SCS(un_normalize_dual)(ScsScaling *scal, 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
 }