scs 0.3.2 → 0.4.1

data/vendor/scs/Makefile

@@ -1,7 +1,7 @@
 # MAKEFILE for scs
 include scs.mk
 
-SCS_OBJECTS = src/util.o src/cones.o src/aa.o src/rw.o src/linalg.o src/ctrlc.o src/scs_version.o src/normalize.o
+SCS_OBJECTS = src/util.o src/cones.o src/exp_cone.o src/aa.o src/rw.o src/linalg.o src/ctrlc.o src/scs_version.o src/normalize.o
 SCS_O = src/scs.o
 SCS_INDIR_O = src/scs_indir.o
 
@@ -19,7 +19,7 @@ TARGETS = $(OUT)/demo_socp_indirect $(OUT)/demo_socp_direct $(OUT)/run_from_file
 default: $(TARGETS) $(OUT)/libscsdir.a $(OUT)/libscsindir.a $(OUT)/libscsdir.$(SHARED) $(OUT)/libscsindir.$(SHARED)
 	@echo "****************************************************************************************"
 	@echo "Successfully compiled scs, copyright Brendan O'Donoghue 2012."
-	@echo "To test, type '$(OUT)/demo_socp_direct' to solve a random SOCP."
+	@echo "To test, run 'make test' and then '$(OUT)/run_tests_direct'."
 	@echo "**********************************************************************************"
 ifneq ($(USE_LAPACK), 0)
 	@echo "Compiled with blas and lapack, can solve LPs, SOCPs, SDPs, ECPs, and PCPs"
@@ -41,6 +41,7 @@ $(SCS_INDIR_O): src/scs.c $(INC_FILES)
 
 src/util.o	: src/util.c $(INC_FILES)
 src/cones.o	: src/cones.c $(INC_FILES)
+src/exp_cone.o	: src/exp_cone.c $(INC_FILES)
 src/aa.o	: src/aa.c $(INC_FILES)
 src/rw.o	: src/rw.c $(INC_FILES)
 src/linalg.o: src/linalg.c $(INC_FILES)
@@ -49,6 +50,7 @@ src/scs_version.o: src/scs_version.c $(INC_FILES)
 
 $(DIRSRC)/private.o: $(DIRSRC)/private.c  $(DIRSRC)/private.h
 $(INDIRSRC)/indirect/private.o: $(INDIRSRC)/private.c $(INDIRSRC)/private.h
+$(MKLSRC)/private.o: $(MKLSRC)/private.c  $(MKLSRC)/private.h
 $(LINSYS)/scs_matrix.o: $(LINSYS)/scs_matrix.c $(LINSYS)/scs_matrix.h
 $(LINSYS)/csparse.o: $(LINSYS)/csparse.c $(LINSYS)/csparse.h
 
@@ -62,45 +64,68 @@ $(OUT)/libscsindir.a: $(SCS_INDIR_O) $(SCS_OBJECTS) $(INDIRSRC)/private.o $(LINS
 	$(ARCHIVE) $@ $^
 	- $(RANLIB) $@
 
+$(OUT)/libscsmkl.a: $(SCS_O) $(SCS_OBJECTS) $(MKLSRC)/private.o $(LINSYS)/scs_matrix.o $(LINSYS)/csparse.o
+	mkdir -p $(OUT)
+	$(ARCHIVE) $@ $^
+	- $(RANLIB) $@
+
 $(OUT)/libscsdir.$(SHARED): $(SCS_O) $(SCS_OBJECTS) $(DIRSRC)/private.o $(AMD_OBJS) $(LDL_OBJS) $(LINSYS)/scs_matrix.o $(LINSYS)/csparse.o
 	mkdir -p $(OUT)
-	$(CC) $(CFLAGS) -shared -Wl,$(SONAME),$(@:$(OUT)/%=%) -o $@ $^ $(LDFLAGS)
+	$(CC) $(CFLAGS) -shared -Wl,$(SONAME),$(@:$(OUT)/%=%) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS)
 
 $(OUT)/libscsindir.$(SHARED): $(SCS_INDIR_O) $(SCS_OBJECTS) $(INDIRSRC)/private.o $(LINSYS)/scs_matrix.o $(LINSYS)/csparse.o
 	mkdir -p $(OUT)
-	$(CC) $(CFLAGS) -shared -Wl,$(SONAME),$(@:$(OUT)/%=%) -o $@ $^ $(LDFLAGS)
+	$(CC) $(CFLAGS) -shared -Wl,$(SONAME),$(@:$(OUT)/%=%) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS)
+
+$(OUT)/libscsmkl.$(SHARED): $(SCS_O) $(SCS_OBJECTS) $(MKLSRC)/private.o $(LINSYS)/scs_matrix.o $(LINSYS)/csparse.o
+	mkdir -p $(OUT)
+	$(CC) $(CFLAGS) -shared -Wl,$(SONAME),$(@:$(OUT)/%=%) -o $@ $^ $(LDFLAGS) $(MKLFLAGS)
 
 $(OUT)/demo_socp_direct: test/random_socp_prob.c $(OUT)/libscsdir.a
-	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS)
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS)
 
 $(OUT)/demo_socp_indirect: test/random_socp_prob.c $(OUT)/libscsindir.a
-	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS)
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS)
+
+$(OUT)/demo_socp_mkl: test/random_socp_prob.c $(OUT)/libscsmkl.a
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(MKLFLAGS)
 
 $(OUT)/run_from_file_direct: test/run_from_file.c $(OUT)/libscsdir.a
-	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS)
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS)
 
 $(OUT)/run_from_file_indirect: test/run_from_file.c $(OUT)/libscsindir.a
-	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS)
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS)
 
 $(OUT)/run_from_file_gpu_indirect: test/run_from_file.c $(OUT)/libscsgpuindir.a
-	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(CULDFLAGS)
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS) $(CULDFLAGS)
 
 # basic testing
 .PHONY: test
 test: $(OUT)/run_tests_indirect $(OUT)/run_tests_direct
 $(OUT)/run_tests_indirect: test/run_tests.c $(OUT)/libscsindir.a
-	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) -Itest
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS) -Itest
 $(OUT)/run_tests_direct: test/run_tests.c $(OUT)/libscsdir.a
-	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) -Itest
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS) -Itest
+$(OUT)/run_tests_mkl: test/run_tests.c $(OUT)/libscsmkl.a
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(MKLFLAGS) -Itest
+
 
 .PHONY: test_gpu
 test_gpu: $(OUT)/run_tests_gpu_indirect # $(OUT)/run_tests_gpu_direct
 
+.PHONY: mkl
+mkl: mklroot $(OUT)/libscsmkl.a $(OUT)/libscsmkl.$(SHARED) $(OUT)/run_tests_mkl $(OUT)/demo_socp_mkl
+mklroot:
+ifndef MKLROOT
+	$(error MKLROOT is undefined, set MKLROOT to the MKL install location)
+endif
+
+
 $(OUT)/run_tests_gpu_indirect: test/run_tests.c $(OUT)/libscsgpuindir.a
-	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(CULDFLAGS) -Itest
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS) $(CULDFLAGS) -Itest
 
 # $(OUT)/run_tests_gpu_direct: test/run_tests.c $(OUT)/libscsgpudir.a
-# 	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(CULDFLAGS) -Itest
+# 	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS) $(CULDFLAGS) -Itest
 
 # REQUIRES GPU AND CUDA INSTALLED
 gpu: gpu_indirect # gpu_direct
@@ -119,7 +144,7 @@ $(GPUINDIR)/private.o: $(GPUINDIR)/private.c
 
 # $(OUT)/libscsgpudir.$(SHARED): $(SCS_O) $(SCS_OBJECTS) $(GPUDIR)/private.o $(AMD_OBJS) $(LINSYS)/scs_matrix.o $(LINSYS)/gpu/gpu.o
 #	 mkdir -p $(OUT)
-# 	$(CC) $(CFLAGS) -shared -Wl,$(SONAME),$(@:$(OUT)/%=%) -o $@ $^ $(LDFLAGS) $(CULDFLAGS)
+# 	$(CC) $(CFLAGS) -shared -Wl,$(SONAME),$(@:$(OUT)/%=%) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS) $(CULDFLAGS)
 
 # $(OUT)/libscsgpudir.a: $(SCS_INDIR_O) $(SCS_OBJECTS) $(GPUDIR)/private.o $(AMD_OBJS) $(LINSYS)/scs_matrix.o $(LINSYS)/gpu/gpu.o
 #  	mkdir -p $(OUT)
@@ -128,7 +153,7 @@ $(GPUINDIR)/private.o: $(GPUINDIR)/private.c
 
 $(OUT)/libscsgpuindir.$(SHARED): $(SCS_O) $(SCS_OBJECTS) $(GPUINDIR)/private.o $(LINSYS)/scs_matrix.o $(LINSYS)/csparse.o $(LINSYS)/gpu/gpu.o
 	mkdir -p $(OUT)
-	$(CC) $(CFLAGS) -shared -Wl,$(SONAME),$(@:$(OUT)/%=%) -o $@ $^ $(LDFLAGS) $(CULDFLAGS)
+	$(CC) $(CFLAGS) -shared -Wl,$(SONAME),$(@:$(OUT)/%=%) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS) $(CULDFLAGS)
 
 $(OUT)/libscsgpuindir.a: $(SCS_INDIR_O) $(SCS_OBJECTS) $(GPUINDIR)/private.o $(LINSYS)/scs_matrix.o $(LINSYS)/csparse.o $(LINSYS)/gpu/gpu.o
 	mkdir -p $(OUT)
@@ -136,14 +161,14 @@ $(OUT)/libscsgpuindir.a: $(SCS_INDIR_O) $(SCS_OBJECTS) $(GPUINDIR)/private.o $(L
 	- $(RANLIB) $@
 
 # $(OUT)/demo_socp_gpu_direct: test/random_socp_prob.c $(OUT)/libscsgpudir.a
-# 	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(CULDFLAGS)
+# 	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS) $(CULDFLAGS)
 
 $(OUT)/demo_socp_gpu_indirect: test/random_socp_prob.c $(OUT)/libscsgpuindir.a
-	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(CULDFLAGS)
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS) $(CULDFLAGS)
 
 .PHONY: clean purge
 clean:
-	@rm -rf $(TARGETS) $(SCS_O) $(SCS_INDIR_O) $(SCS_OBJECTS) $(AMD_OBJS) $(LDL_OBJS) $(LINSYS)/*.o $(DIRSRC)/*.o $(INDIRSRC)/*.o $(GPUDIR)/*.o $(GPUINDIR)/*.o $(LINSYS)/gpu/*.o
+	@rm -rf $(TARGETS) $(SCS_O) $(SCS_INDIR_O) $(SCS_OBJECTS) $(AMD_OBJS) $(LDL_OBJS) $(LINSYS)/*.o $(DIRSRC)/*.o $(INDIRSRC)/*.o $(MKLSRC)/*.o $(GPUDIR)/*.o $(GPUINDIR)/*.o $(LINSYS)/gpu/*.o
 	@rm -rf $(OUT)/*.dSYM
 	@rm -rf matlab/*.mex*
 	@rm -rf .idea

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.3`.
 
 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

@@ -12,16 +12,17 @@ extern "C" {
 #define SCS(x) _scs_##x
 #endif
 
-/* SCS VERSION NUMBER ----------------------------------------------    */
+/* SCS VERSION NUMBER ----------------------------------------------     */
 /* string literals automatically null-terminated */
-#define SCS_VERSION ("3.1.1")
+#define SCS_VERSION ("3.2.3")
 
 /* verbosity level */
 #ifndef VERBOSITY
 #define VERBOSITY (0)
 #endif
 
-/* DEFAULT SOLVER PARAMETERS AND SETTINGS --------------------------    */
+/* DEFAULT SOLVER PARAMETERS AND SETTINGS --------------------------     */
+/* If you update any of these you must update the documentation manually */
 #define MAX_ITERS (100000)
 #define EPS_REL (1E-4)
 #define EPS_ABS (1E-4)
@@ -39,29 +40,50 @@ extern "C" {
 #define LOG_CSV_FILENAME (0)
 #define TIME_LIMIT_SECS (0.)
 
-/* redefine printfs and memory allocators as needed */
+/* redefine printfs as needed */
+#if NO_PRINTING > 0     /* Disable all printing */
+#define scs_printf(...) /* No-op */
+#else
 #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
 #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();                           \
     PySys_WriteStdout(__VA_ARGS__);                                            \
     PyGILState_Release(gilstate);                                              \
   }
+#elif defined R_LANG
+#include <R_ext/Print.h> /* Rprintf etc */
+#include <stdio.h>
+#include <stdlib.h>
+#define scs_printf Rprintf
+#else
+#include <stdio.h>
+#include <stdlib.h>
+#define scs_printf printf
+#endif
+#endif
+
+/* redefine memory allocators as needed */
+#ifdef MATLAB_MEX_FILE
+#include "mex.h"
+#define scs_free mxFree
+#define scs_malloc mxMalloc
+#define scs_calloc mxCalloc
+#define scs_realloc mxRealloc
+#elif defined PYTHON
+#include <Python.h>
 #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
@@ -73,10 +95,8 @@ static inline void *scs_calloc(size_t count, size_t size) {
 }
 #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
@@ -84,7 +104,6 @@ static inline void *scs_calloc(size_t count, size_t size) {
 #else
 #include <stdio.h>
 #include <stdlib.h>
-#define scs_printf printf
 #define scs_free free
 #define scs_malloc malloc
 #define scs_calloc calloc
@@ -107,8 +126,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
@@ -145,8 +162,9 @@ static inline void *scs_calloc(size_t count, size_t size) {
 /* 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))
+#define _DIV_EPS_TOL (1E-18)
+#define SAFEDIV_POS(X, Y)                                                      \
+  ((Y) < _DIV_EPS_TOL ? ((X) / _DIV_EPS_TOL) : (X) / (Y))
 
 #if VERBOSITY > 0
 #define PRINT_INTERVAL (1)

data/vendor/scs/include/linsys.h

@@ -23,15 +23,15 @@ extern "C" {
  *  @return            Linear system solver workspace.
  *
  */
-ScsLinSysWork *SCS(init_lin_sys_work)(const ScsMatrix *A, const ScsMatrix *P,
-                                      const scs_float *diag_r);
+ScsLinSysWork *scs_init_lin_sys_work(const ScsMatrix *A, const ScsMatrix *P,
+                                     const scs_float *diag_r);
 
 /**
  * Frees `ScsLinSysWork` structure and associated allocated memory.
  *
  *  @param  w    Linear system private workspace.
  */
-void SCS(free_lin_sys_work)(ScsLinSysWork *w);
+void scs_free_lin_sys_work(ScsLinSysWork *w);
 
 /**
  * Solves the linear system as required by SCS at each iteration:
@@ -48,11 +48,11 @@ void SCS(free_lin_sys_work)(ScsLinSysWork *w);
  *  @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.
+ *  @return status != 0 indicates failure.
  *
  */
-scs_int SCS(solve_lin_sys)(ScsLinSysWork *w, scs_float *b, const scs_float *s,
-                           scs_float tol);
+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
@@ -62,14 +62,14 @@ scs_int SCS(solve_lin_sys)(ScsLinSysWork *w, scs_float *b, const scs_float *s,
  *  @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);
+void scs_update_lin_sys_diag_r(ScsLinSysWork *w, const scs_float *new_diag_r);
 
 /**
  * Name of the linear solver.
  *
  * @return name of method.
  */
-const char *SCS(get_lin_sys_method)(void);
+const char *scs_get_lin_sys_method(void);
 
 #ifdef __cplusplus
 }

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

@@ -1,5 +1,9 @@
-/* This file contains the outward facing SCS API. */
-/* It includes all the input/output data structs and the API functions. */
+/*
+ * Public header containing the outward facing SCS API. It includes all the
+ * input/output data structs and the API functions.  Make sure this file and
+ * `scs_types.h` are somewhere appropriate and then use `#include "scs.h"` to
+ * access the SCS public API.
+ */
 
 #ifndef SCS_H_GUARD
 #define SCS_H_GUARD
@@ -11,6 +15,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 +122,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 +135,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 +211,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 +221,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 +273,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 +287,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_types.h

@@ -1,5 +1,7 @@
 /*
- * Definitions of primitive types used in SCS.
+ * Pulic header including definitions of primitive types used in SCS.
+ * Make sure this file and `scs.h` are somewhere appropriate and then use
+ * `#include "scs.h"` to access the SCS public API.
  */
 
 #ifndef SCS_TYPES_H_GUARD

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,12 +54,12 @@ 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 */
+  scs_float *b_orig, *c_orig;     /* original unnormalized b and c vectors */
+  scs_float nm_b_orig, nm_c_orig; /* unnormalized NORM(b), NORM(c) */
+  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 */
@@ -64,17 +67,12 @@ struct SCS_WORK {
   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

@@ -11,7 +11,7 @@ extern "C" {
 #include <stdlib.h>
 
 /* timing code courtesy of A. Domahidi */
-#if (defined NOTIMER)
+#if (defined NO_TIMER)
 typedef void *SCS(timer);
 #elif (defined _WIN32 || defined _WIN64 || defined _WINDLL)
 /* Use Windows QueryPerformanceCounter for timing */
@@ -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
 }