scs 0.2.3 → 0.3.0

data/vendor/scs/README.md

@@ -1,270 +1,12 @@
 <h1 align="center" margin=0px>
-<img src="https://github.com/cvxgrp/scs/blob/master/docs/scs_logo.png" alt="Intersection of a cone and a polyhedron" width="450">
+<img src="https://github.com/cvxgrp/scs/blob/master/docs/src/_static/scs_logo.png" alt="Intersection of a cone and a polyhedron" width="450">
 </h1>
 
-![Build Status](https://github.com/cvxgrp/scs/actions/workflows/build.yml/badge.svg)
+[![Build Status](https://github.com/cvxgrp/scs/actions/workflows/build.yml/badge.svg)](https://github.com/cvxgrp/scs/actions/workflows/build.yml)
+[![Coverage Status](https://coveralls.io/repos/github/cvxgrp/scs/badge.svg?branch=master)](https://coveralls.io/github/cvxgrp/scs?branch=master)
 
 
 SCS (`splitting conic solver`) is a numerical optimization package for solving
-large-scale convex cone problems, based on our paper [Conic Optimization via
-Operator Splitting and Homogeneous Self-Dual
-Embedding](http://www.stanford.edu/~boyd/papers/scs.html). It is written in C
-and can be used in other C, C++,
-[Python](https://github.com/bodono/scs-python),
-[Matlab](https://github.com/bodono/scs-matlab),
-[R](https://github.com/bodono/scs-r),
-[Julia](https://github.com/JuliaOpt/SCS.jl), and
-[Ruby](https://github.com/ankane/scs),
-programs via the linked
-interfaces. It can also be called as a solver from convex optimization
-toolboxes [CVX](http://cvxr.com/cvx/) (3.0 or later),
-[CVXPY](https://github.com/cvxgrp/cvxpy),
-[Convex.jl](https://github.com/jump-dev/Convex.jl),
-[JuMP.jl](https://github.com/jump-dev/JuMP.jl), and
-[Yalmip](https://github.com/johanlofberg/YALMIP).
+large-scale convex cone problems. The current version is `3.0.0`.
 
-The current version is `2.1.4`. If you wish to cite SCS, please use the
-following:
-```
-@article{ocpb:16,
-    author       = {B. O'Donoghue and E. Chu and N. Parikh and S. Boyd},
-    title        = {Conic Optimization via Operator Splitting and Homogeneous Self-Dual Embedding},
-    journal      = {Journal of Optimization Theory and Applications},
-    month        = {June},
-    year         = {2016},
-    volume       = {169},
-    number       = {3},
-    pages        = {1042-1068},
-    url          = {http://stanford.edu/~boyd/papers/scs.html},
-}
-@misc{scs,
-    author       = {B. O'Donoghue and E. Chu and N. Parikh and S. Boyd},
-    title        = {{SCS}: Splitting Conic Solver, version 2.1.4},
-    howpublished = {\url{https://github.com/cvxgrp/scs}},
-    month        = nov,
-    year         = 2019
-}
-```
-
-----
-SCS numerically solves convex cone programs using the alternating direction
-method of multipliers
-([ADMM](http://web.stanford.edu/~boyd/papers/admm_distr_stats.html)).  It
-returns solutions to both the primal and dual problems if the problem is
-feasible, or a certificate of infeasibility otherwise. It solves the following
-primal cone problem:
-
-```
-minimize        c'x
-subject to      Ax + s = b
-                s in K
-```
-over variables `x` and `s`, where `A`, `b` and `c` are user-supplied data and
-`K` is a user-defined convex cone.  The dual problem is given by
-```
-maximize        -b'y
-subject to      -A'y == c
-                y in K^*
-```
-over variable `y`, where `K^*` denotes the dual cone to `K`.
-
-The cone `K` can be any Cartesian product of the following primitive cones:
-+ zero cone `{x | x = 0 }` (dual to the free cone `{x | x in R}`)
-+ positive orthant `{x | x >= 0}`
-+ second-order cone `{(t,x) | ||x||_2 <= t}`
-+ positive semidefinite cone `{ X | min(eig(X)) >= 0, X = X^T }`
-+ exponential cone `{(x,y,z) | y e^(x/y) <= z, y>0 }`
-+ dual exponential cone `{(u,v,w) | −u e^(v/u) <= e w, u<0}`
-+ power cone `{(x,y,z) | x^a * y^(1-a) >= |z|, x>=0, y>=0}`
-+ dual power cone `{(u,v,w) | (u/a)^a * (v/(1-a))^(1-a) >= |w|, u>=0, v>=0}`
-
-The rows of the data matrix `A` correspond to the cones in `K`.  **The rows of
-`A` must be in the order of the cones given above, i.e., first come the rows
-that correspond to the zero/free cones, then those that correspond to the
-positive orthants, then SOCs, etc.** For a `k` dimensional semidefinite cone
-when interpreting the rows of the data matrix `A` SCS assumes that the `k x k`
-matrix variable has been vectorized by scaling the off-diagonal entries by
-`sqrt(2)` and stacking the **lower triangular elements column-wise** to create a
-vector of length `k(k+1)/2`. See the section on semidefinite programming below.
-
-At termination SCS returns solution `(x*, s*, y*)` if the problem is feasible,
-or a certificate of infeasibility otherwise. See
-[here](http://web.stanford.edu/~boyd/cvxbook/) for more details about
-cone programming and certificates of infeasibility.
-
-**Anderson Acceleration**
-
-By default SCS uses Anderson acceleration (AA) to speed up convergence. The
-number of iterates that SCS uses in the AA calculation can be controlled by the
-parameter `acceleration_lookback` in the settings struct. It defaults to 10.  AA
-is available as a standalone package [here](https://github.com/cvxgrp/aa).  More
-details are available in our paper on AA
-[here](https://stanford.edu/~boyd/papers/nonexp_global_aa1.html).
-
-**Semidefinite Programming**
-
-SCS assumes that the matrix variables and the input data corresponding to
-semidefinite cones have been vectorized by **scaling the off-diagonal entries by
-`sqrt(2)`** and stacking the lower triangular elements **column-wise**. For a `k
-x k` matrix variable (or data matrix) this operation would create a vector of
-length `k(k+1)/2`. Scaling by `sqrt(2)` is required to preserve the
-inner-product.
-
-**To recover the matrix solution this operation must be inverted on the
-components of the vector returned by SCS corresponding to semidefinite cones**.
-That is, the off-diagonal entries must be scaled by `1/sqrt(2)` and the upper
-triangular entries are filled in by copying the values of lower triangular
-entries.
-
-More explicitly, we want to express
-`Tr(C X)` as `vec(C)'*vec(X)`, where the `vec` operation takes the `k x k` matrix
-```
-X = [ X11 X12 ... X1k
-      X21 X22 ... X2k
-      ...
-      Xk1 Xk2 ... Xkk ]
-```
-and produces a vector consisting of
-```
-vec(X) = (X11, sqrt(2)*X21, ..., sqrt(2)*Xk1, X22, sqrt(2)*X32, ..., Xkk).
-```
-
-**Linear equation solvers**
-
-Each iteration of SCS requires the solution of a set of linear equations.  This
-package includes two implementations for solving linear equations: a direct
-solver which uses a cached LDL factorization and an indirect solver based on
-conjugate gradients. The indirect solver can be run on either the cpu or
-gpu.
-
-The direct solver uses external numerical linear algebra packages:
-* [QDLDL](https://github.com/oxfordcontrol/qdldl)
-* [AMD](https://github.com/DrTimothyAldenDavis/SuiteSparse).
-
-### Using SCS in C
-Typing `make` at the command line will compile the code and create SCS libraries
-in the `out` folder. To run the tests execute:
-```sh
-make
-make test
-test/run_tests
-```
-
-If `make` completes successfully, it will produce two static library files,
-`libscsdir.a`, `libscsindir.a`, and two dynamic library files `libscsdir.ext`,
-`libscsindir.ext` (where `.ext` extension is platform dependent) in the same
-folder. It will also produce two demo binaries in the `out` folder named
-`demo_socp_direct`, and `demo_socp_indirect`. If you have a GPU and have CUDA
-installed, you can also execute `make gpu` to compile SCS to run on the GPU
-which will create additional libraries and demo binaries in the `out` folder
-corresponding to the gpu version. Note that the GPU version requires 32 bit
-ints, which can be enforced by compiling with `DLONG=0`.
-
-To use the libraries in your own source code, compile your code with the linker
-option `-L(PATH_TO_SCS_LIBS)` and `-lscsdir` or `-lscsindir` (as needed).  The
-API and required data structures are defined in the file `include/scs.h`.  The
-four main API functions are:
-
-* `ScsWork * scs_init(const ScsData * d, const ScsCone * k, ScsInfo * info);`
-
-    This initializes the ScsWork struct containing the workspace that scs will
-    use, and performs the necessary preprocessing (e.g. matrix factorization).
-    All inputs `d`, `k`, and `info` must be memory allocated before calling.
-
-* `scs_int scs_solve(ScsWork * w, const ScsData * d, const ScsCone * k, ScsSolution * sol, ScsInfo * info);`
-
-    This solves the problem as defined by ScsData `d` and ScsCone `k` using the
-    workspace in `w`. The solution is returned in `sol` and information about
-    the solve is returned in `info` (outputs must have memory allocated before
-    calling).  None of the inputs can be NULL. You can call `scs_solve` many
-    times for one call to `scs_init`, so long as the matrix `A` does not change
-    (vectors `b` and `c` can change).
-
-* `void scs_finish(ScsWork * w);`
-
-    Called after all solves completed to free allocated memory and other
-    cleanup.
-
-* `scs_int scs(const ScsData * d, const ScsCone * k, ScsSolution * sol, ScsInfo * info);`
-
-    Convenience method that simply calls all the above routines in order, for
-    cases where the workspace does not need to be reused. All inputs must have
-    memory allocated before this call.
-
-The data matrix `A` is specified in column-compressed format and the vectors `b`
-and `c` are specified as dense arrays. The solutions `x` (primal), `s` (slack),
-and `y` (dual) are returned as dense arrays. Cones are specified as the struct
-defined in `include/scs.h`, the rows of `A` must correspond to the cones in the
-exact order as specified by the cone struct (i.e. put linear cones before
-second-order cones etc.).
-
-**Warm-start**
-
-You can warm-start SCS (supply a guess of the solution) by setting `warm_start`
-in the ScsData struct to `1` and supplying the warm-starts in the ScsSolution
-struct (`x`,`y`, and `s`). All inputs must be warm-started if any one is. These
-are used to initialize the iterates in `scs_solve`.
-
-**Re-using matrix factorization**
-
-If using the direct version you can factorize the matrix once and solve many
-times. Simply call `scs_init` once, and use `scs_solve` many times with the same
-workspace, changing the input data `b` and `c` (and optionally warm-starts) for
-each iteration.
-
-**Using your own linear system solver**
-
-To use your own linear system solver simply implement all the methods and the
-two structs in `include/linsys.h` and plug it in.
-
-**BLAS / LAPACK install error**
-
-If you get an error like `cannot find -lblas` or `cannot find -llapack`, then
-you need to install blas and lapack and / or update your environment variables
-to point to the install locations.
-
-### Using SCS with cmake
-
-Thanks to [`CMake`](http://cmake.org) buildsystem, scs can be easily compiled
-and linked by other `CMake` projects. To use the `cmake` buld system please run
-the following commands:
-```
-cd scs
-mkdir build
-cd build
-cmake -DCMAKE_INSTALL_PREFIX:PATH=<custom-folder> ../
-make
-make install
-```
-
-You may also want to compile the tests. In this case when you configure the project,
-please call the following command
-```
-cmake -DCMAKE_INSTALL_PREFIX:PATH=<custom-folder> -DBUILD_TESTING=ON ../
-make
-ctest
-```
-
-By default the build-system will compile the library as `shared`. If you want to
-compile it as `static`, please call the following command when you configure the
-project
-```
-cmake -DCMAKE_INSTALL_PREFIX:PATH=<custom-folder> -BUILD_SHARED_LIBS=OFF ../
-make
-```
-
-The `cmake` build-system exports two CMake targets called `scs::scsdir` and
-`scs::scsindir` which can be imported using the `find_package` CMake command
-and used by calling `target_link_libraries` as in the following example:
-```cmake
-cmake_minimum_required(VERSION 3.0)
-project(myproject)
-find_package(scs REQUIRED)
-add_executable(example example.cpp)
-
-# To use the direct method
-target_link_libraries(example scs::scsdir)
-
-# To use the indirect method
-target_link_libraries(example scs::scsindir)
-```
+The full documentation is available [here](https://www.cvxgrp.org/scs/).

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

@@ -11,34 +11,34 @@ extern "C" {
 
 /* 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
+   */
+  scs_float *s; /* used for Moreau decomposition in projection */
+  scs_int cone_len;
+  /* 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, const ScsScaling *scal,
+                            scs_int cone_len);
 char *SCS(get_cone_header)(const ScsCone *k);
 scs_int SCS(validate_cones)(const ScsData *d, const ScsCone *k);
+scs_int SCS(set_cone_boundaries)(const ScsCone *k, scs_int **cone_boundaries);
 
-/* 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 normalize);
 void SCS(finish_cone)(ScsConeWork *c);
-char *SCS(get_cone_summary)(const ScsInfo *info, ScsConeWork *c);
+
+void SCS(set_rho_y_vec)(const ScsCone *k, scs_float scale, scs_float *rho_y_vec,
+                        scs_int m);
 
 #ifdef __cplusplus
 }

data/vendor/scs/include/glbopts.h

@@ -12,8 +12,8 @@ extern "C" {
 #endif
 
 /* SCS VERSION NUMBER ----------------------------------------------    */
-#define SCS_VERSION \
-  ("2.1.4") /* 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);