scs 0.3.0 → 0.4.0

data/vendor/scs/include/glbopts.h

@@ -5,27 +5,16 @@
 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                                                            \
-  ("3.0.0") /* 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.2.0")
 
 /* verbosity level */
 #ifndef VERBOSITY
@@ -54,30 +43,31 @@ extern "C" {
 #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>
+/* 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);                                              \
   }
-/* 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
+#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) {
+#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;
@@ -88,47 +78,21 @@ static inline void *_scs_calloc(size_t count, size_t size) {
 #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;
-#else
-typedef long scs_int;
-#endif
-*/
-typedef long long scs_int;
-#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
@@ -136,7 +100,6 @@ typedef double scs_float;
 #define INFINITY NAN
 #endif
 #else
-typedef float scs_float;
 #ifndef NAN
 #define NAN ((float)0x7fc00000)
 #endif
@@ -145,8 +108,6 @@ typedef float scs_float;
 #endif
 #endif
 
-#define SCS_NULL 0
-
 #ifndef MAX
 #define MAX(a, b) (((a) > (b)) ? (a) : (b))
 #endif

data/vendor/scs/include/linalg.h

@@ -5,7 +5,7 @@
 extern "C" {
 #endif
 
-#include "scs.h"
+#include "glbopts.h"
 #include <math.h>
 
 void SCS(scale_array)(scs_float *a, const scs_float b, scs_int len);
@@ -17,6 +17,7 @@ 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,6 +5,7 @@
 extern "C" {
 #endif
 
+#include "glbopts.h"
 #include "scs.h"
 
 /* This is the API that any new linear system solver must implement */
@@ -16,15 +17,14 @@ extern "C" {
 /**
  * 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.
+ *  @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,
-                                      scs_float *rho_y_vec, scs_float rho_x);
+                                      const scs_float *diag_r);
 
 /**
  * Frees `ScsLinSysWork` structure and associated allocated memory.
@@ -34,15 +34,15 @@ ScsLinSysWork *SCS(init_lin_sys_work)(const ScsMatrix *A, const ScsMatrix *P,
 void SCS(free_lin_sys_work)(ScsLinSysWork *w);
 
 /**
- * Solves the linear system required by SCS at each iteration:
+ * Solves the linear system as required by SCS at each iteration:
  * \f[
  *    \begin{bmatrix}
- *    (\rho_x I + P) & A^\top \\
- *     A   &  -\mathrm{diag}(\rho_y) \\
+ *    (R_x + P) & A^\top \\
+ *     A   &  -R_y \\
  *    \end{bmatrix} x = b
  *  \f]
  *
- *  for `x`. Overwrites `b` with result.
+ *  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.
@@ -54,15 +54,15 @@ void SCS(free_lin_sys_work)(ScsLinSysWork *w);
 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
+ *  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  rho_y_vec  `rho_y` diagonal entries.
+ *  @param  w             Linear system private workspace.
+ *  @param  new_diag_r    Updated `diag_r`, diagonal entries of R.
  *
  */
-void SCS(update_lin_sys_rho_y_vec)(ScsLinSysWork *w, scs_float *rho_y_vec);
+void SCS(update_lin_sys_diag_r)(ScsLinSysWork *w, const scs_float *new_diag_r);
 
 /**
  * Name of the linear solver.

data/vendor/scs/include/normalize.h

@@ -5,12 +5,14 @@
 extern "C" {
 #endif
 
-#include "scs.h"
+#include "glbopts.h"
+#include "scs_work.h"
 
-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);
+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);
+void SCS(un_normalize_dual)(ScsScaling *scal, scs_float *r);
 
 #ifdef __cplusplus
 }

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,3 +1,6 @@
+/* This file contains the outward facing SCS API. */
+/* It includes all the input/output data structs and the API functions. */
+
 #ifndef SCS_H_GUARD
 #define SCS_H_GUARD
 
@@ -5,20 +8,36 @@
 extern "C" {
 #endif
 
-#include <string.h>
+/* Contains definitions of primitive types `scs_int` and `scs_float`. */
+#include "scs_types.h"
+
+#define SCS_NULL 0 /* NULL type */
 
-#include "aa.h"
-#include "glbopts.h"
+/* The following abstract structs are implemented later. */
 
 /** Struct containing acceleration workspace. Implemented by acceleration. */
-typedef struct SCS_ACCEL_WORK ScsAccelWork;
+typedef struct ACCEL_WORK AaWork;
 /** Struct containing cone projection workspace. Implemented by cones. */
 typedef struct SCS_CONE_WORK ScsConeWork;
 /** Struct containing linear system workspace. Implemented by linear solver. */
 typedef struct SCS_LIN_SYS_WORK ScsLinSysWork;
+/** Struct containing SCS workspace. Implemented in `scs_work.h`. */
+typedef struct SCS_WORK ScsWork;
 
-/** This defines the data matrices which should be supplied in column compressed
- *  format with zero based indexing.
+/* SCS returns one of the following integer exit flags:            */
+#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)
+
+/** This defines the data matrices which should be supplied in compressed
+ *  sparse column format with zero based indexing.
  */
 typedef struct {
   /** Matrix values, size: number of non-zeros. */
@@ -99,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;
@@ -112,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;
@@ -120,7 +139,10 @@ typedef struct {
 
 /** Contains primal-dual solution arrays or a certificate of infeasibility.
  *  Check the exit flag to determine whether this contains a solution or a
- *  certificate. */
+ *  certificate. If when passed into SCS the members `x`, `y`, `s` are
+ *  NULL then SCS will allocate memory for them which should be managed
+ *  by the user to prevent memory leaks.
+ */
 typedef struct {
   /** Primal variable. */
   scs_float *x;
@@ -136,6 +158,8 @@ typedef struct {
   scs_int iter;
   /** Status string, e.g. 'solved'. */
   char status[128];
+  /** Linear system solver used. */
+  char lin_sys_solver[128];
   /** Status as scs_int, defined in glbopts.h. */
   scs_int status_val;
   /** Number of updates to scale. */
@@ -176,84 +200,16 @@ typedef struct {
   scs_float accel_time;
 } ScsInfo;
 
-/* the following structs are not exposed to user */
-
-/** Contains normalization variables. */
-typedef struct {
-  scs_float *D, *E; /* for normalization */
-  scs_float primal_scale, dual_scale;
-} ScsScaling;
-
-/** Holds residual information. */
-typedef struct {
-  scs_int last_iter;
-  scs_float xt_p_x;     /* x' P x  */
-  scs_float xt_p_x_tau; /* x'Px * tau^2 *not* divided out */
-  scs_float ctx;
-  scs_float ctx_tau; /* tau *not* divided out */
-  scs_float bty;
-  scs_float bty_tau; /* tau *not* divided out */
-  scs_float pobj;    /* primal objective */
-  scs_float dobj;    /* dual objective */
-  scs_float gap;     /* pobj - dobj */
-  scs_float tau;
-  scs_float kap;
-  scs_float res_pri;
-  scs_float res_dual;
-  scs_float res_infeas;
-  scs_float res_unbdd_p;
-  scs_float res_unbdd_a;
-  /* tau NOT divided out */
-  scs_float *ax, *ax_s, *px, *aty, *ax_s_btau, *px_aty_ctau;
-} ScsResiduals;
-
-/** Workspace for SCS */
-typedef struct {
-  /* x_prev = x from previous iteration */
-  scs_int time_limit_reached; /* set if the time-limit is reached */
-  scs_float *u, *u_t;
-  scs_float *v, *v_prev;
-  scs_float *rsk;                /* rsk [ r; s; kappa ] */
-  scs_float *h;                  /* h = [c; b] */
-  scs_float *g;                  /* g = (I + M)^{-1} h */
-  scs_float *lin_sys_warm_start; /* linear system warm-start (indirect only) */
-  scs_float *rho_y_vec; /* vector of rho y parameters (affects cone project) */
-  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_int *cone_boundaries;    /* array with boundaries of cones */
-  scs_int cone_boundaries_len; /* total length of cones */
-  /* 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 */
-  scs_float sum_log_scale_factor;
-  scs_int last_scale_update_iter, n_log_scale_factor, scale_updates;
-  /* aa norm stat */
-  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 */
-} ScsWork;
-
 /*
- * main library API
+ * Main library API.
  */
 
 /**
  * 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
@@ -261,45 +217,65 @@ 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);
+ScsWork *scs_init(const ScsData *d, const ScsCone *k, const ScsSettings *stgs);
 
 /**
- * Solve quadratic cone program initialized by SCS(init).
+ * 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 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.
  *
- * @param  w     Workspace allocated by init.
- * @param  sol 	 Solver solution struct, will contain solution at termination.
- * @param  info  Solver info reporting.
  * @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.
  *
  * @param  w  Workspace allocated by init, will be deallocated.
  */
-void SCS(finish)(ScsWork *w);
+void scs_finish(ScsWork *w);
 
 /**
  * Solve quadratic cone program defined by data in d and cone k.
  *
  * 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.
- * @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);
@@ -307,13 +283,16 @@ 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);
+void scs_set_default_settings(ScsSettings *stgs);
 
-const char *SCS(version)(void);
-size_t SCS(sizeof_int)(void);
-size_t SCS(sizeof_float)(void);
+/**
+ * Helper function simply returns the current version of SCS as a string.
+ *
+ * @return       SCS version as a string.
+ */
+const char *scs_version(void);
 
 #ifdef __cplusplus
 }

data/vendor/scs/include/scs_types.h

@@ -0,0 +1,34 @@
+/*
+ * Definitions of primitive types used in SCS.
+ */
+
+#ifndef SCS_TYPES_H_GUARD
+#define SCS_TYPES_H_GUARD
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef DLONG
+/*#ifdef _WIN64
+#include <stdint.h>
+typedef int64_t scs_int;
+#else
+typedef long scs_int;
+#endif
+*/
+typedef long long scs_int;
+#else
+typedef int scs_int;
+#endif
+
+#ifndef SFLOAT
+typedef double scs_float;
+#else
+typedef float scs_float;
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif

data/vendor/scs/include/scs_work.h

@@ -0,0 +1,80 @@
+/*
+ * Define ScsWork and related internal-only structs (not part of external API).
+ */
+
+#ifndef SCS_WORK_H_GUARD
+#define SCS_WORK_H_GUARD
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "scs.h"
+
+/** Contains normalization variables. */
+typedef struct {
+  scs_float *D, *E; /* for normalization */
+  scs_int m;        /* Length of D */
+  scs_int n;        /* Length of E */
+  scs_float primal_scale, dual_scale;
+} ScsScaling;
+
+/** Holds residual information. */
+typedef struct {
+  scs_int last_iter;
+  scs_float xt_p_x;     /* x' P x  */
+  scs_float xt_p_x_tau; /* x'Px * tau^2 *not* divided out */
+  scs_float ctx;
+  scs_float ctx_tau; /* tau *not* divided out */
+  scs_float bty;
+  scs_float bty_tau; /* tau *not* divided out */
+  scs_float pobj;    /* primal objective */
+  scs_float dobj;    /* dual objective */
+  scs_float gap;     /* pobj - dobj */
+  scs_float tau;
+  scs_float kap;
+  scs_float res_pri;
+  scs_float res_dual;
+  scs_float res_infeas;
+  scs_float res_unbdd_p;
+  scs_float res_unbdd_a;
+  /* tau NOT divided out */
+  scs_float *ax, *ax_s, *px, *aty, *ax_s_btau, *px_aty_ctau;
+} ScsResiduals;
+
+/** Workspace for SCS. */
+struct SCS_WORK {
+  /* x_prev = x from previous iteration */
+  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 ] */
+  scs_float *h;                  /* h = [c; b] */
+  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) */
+  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;
+  /* Scale updating workspace */
+  scs_float sum_log_scale_factor;
+  scs_int last_scale_update_iter, n_log_scale_factor, scale_updates;
+  /* AA stats */
+  scs_float aa_norm;
+  scs_int rejected_accel_steps, accepted_accel_steps;
+};
+
+#ifdef __cplusplus
+}
+#endif
+#endif

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
 }