scs 0.5.6 → 0.6.0

data/vendor/scs/src/spectral_cones/sum-largest/sum_largest_cone.c

@@ -1,10 +1,10 @@
 #include "cones.h"
-// #include "scs.h"
+/* #include "scs.h" */
 #include "linalg.h"
 #include "scs_blas.h"
 #include "scs_types.h"
 #include "util_spectral_cones.h"
-#include <stdlib.h> // qsort
+#include <stdlib.h> /* qsort */
 
 #define TOL_LARGEST_CONE 1e-9
 
@@ -30,7 +30,8 @@ static void compute_cone_residuals(scs_float t, const scs_float *x,
 #endif
 
 scs_int assert_sorted(scs_float *x, scs_int n) {
-  for (scs_int i = 0; i < n - 1; ++i) {
+  scs_int i;
+  for (i = 0; i < n - 1; ++i) {
     if (x[i] < x[i + 1]) {
       return -1;
     }
@@ -40,53 +41,64 @@ scs_int assert_sorted(scs_float *x, scs_int n) {
 
 scs_int proj_sum_largest_cone_sorted(scs_float *t, scs_float *x, scs_int n,
                                      scs_int k) {
+  scs_int nu, nt;
+  scs_float eta;
+  scs_float t0;
+  scs_float S;
+  scs_float a_u, a_t;
+  scs_float ratio, s1, s3, s;
+  scs_float val;
+  scs_int i;
+
 #ifdef SPECTRAL_DEBUG
   scs_float t00 = *t;
   scs_float *x0 = scs_malloc(n * sizeof(*x0));
+  scs_int status;
   memcpy(x0, x, n * sizeof(*x0));
-  scs_int status = assert_sorted(x, n);
+  status = assert_sorted(x, n);
   if (status < 0) {
     scs_printf("NOT SORTED! \n");
     return status;
   }
 #endif
 
-  // -------------------------------
-  //    Initialize state variables
-  // -------------------------------
+  /* -------------------------------
+   *    Initialize state variables
+   * ------------------------------- */
   assert(k < n && k > 0);
-  scs_int nu = k, nt = 0;
-  scs_float eta = 0.0;
-  scs_float t0 = *t;
-  scs_float S = x[0];
-  for (scs_int i = 1; i < k; ++i) {
+  nu = k;
+  nt = 0;
+  eta = 0.0;
+  t0 = *t;
+  S = x[0];
+  for (i = 1; i < k; ++i) {
     S += x[i];
   }
 
-  scs_float a_u = x[nu - 1], a_t = x[nu];
+  a_u = x[nu - 1];
+  a_t = x[nu];
 
-  // ---------------------------------
-  //           main loop
-  // ---------------------------------
-  scs_float ratio, s1, s3, s;
+  /* ---------------------------------
+   *           main loop
+   * --------------------------------- */
   while (S > *t + TOL_LARGEST_CONE) {
     ratio = (nu == k) ? 1.0 : (scs_float)(nt) / (k - nu);
 
-    // ------------------------------------------------------
-    //                 compute step size
-    // ------------------------------------------------------
+    /* ------------------------------------------------------
+     *                 compute step size
+     * ------------------------------------------------------ */
     s1 = (nu == k) ? a_u - a_t : (a_u - a_t) / (ratio - 1);
     s3 = (S - *t) / (ratio * (nu + 1) + (k - nu));
     s = (nu == 0) ? s3 : MIN(s3, s1);
 
     if (!(nu + nt == n || nt == 0)) {
-      scs_float val = a_t - x[nu + nt];
+      val = a_t - x[nu + nt];
       s = MIN(s, val);
     }
 
-    // --------------------------
-    //        update state
-    // --------------------------
+    /* --------------------------
+     *        update state
+     * -------------------------- */
     eta += s * ratio;
     S -= s * (ratio * nu + k - nu);
     *t = t0 + eta;
@@ -110,8 +122,7 @@ scs_int proj_sum_largest_cone_sorted(scs_float *t, scs_float *x, scs_int n,
 
   nt -= 1;
 
-  // update projection
-  scs_int i;
+  /* update projection */
   for (i = 0; i < nu; ++i) {
     x[i] -= eta;
   }
@@ -121,12 +132,14 @@ scs_int proj_sum_largest_cone_sorted(scs_float *t, scs_float *x, scs_int n,
   }
 
 #ifdef SPECTRAL_DEBUG
-  scs_float residuals[3];
-  compute_cone_residuals(*t, x, t00, x0, residuals, n, k);
-  scs_free(x0);
-  if (residuals[0] > 1e-10 || residuals[1] > 1e-10 ||
-      fabs(residuals[2]) > 1e-10) {
-    return -1;
+  {
+    scs_float residuals[3];
+    compute_cone_residuals(*t, x, t00, x0, residuals, n, k);
+    scs_free(x0);
+    if (residuals[0] > 1e-10 || residuals[1] > 1e-10 ||
+        fabs(residuals[2]) > 1e-10) {
+      return -1;
+    }
   }
 #endif
 
@@ -144,14 +157,15 @@ scs_int cmp_desc(const void *a, const void *b) {
 }
 
 #ifdef SPECTRAL_DEBUG
-// this function is not used in production so fine to allocate memory
+/* this function is not used in production so fine to allocate memory */
 static scs_float sum_largest_val(const scs_float *x, scs_int n, scs_int k) {
   scs_float *x_temp = scs_malloc(n * sizeof(*x));
+  scs_float val = 0.0;
+  scs_int i;
   memcpy(x_temp, x, n * sizeof(*x));
   qsort(x_temp, n, sizeof(*x_temp), cmp_desc);
 
-  scs_float val = 0.0;
-  for (scs_int i = 0; i < k; ++i) {
+  for (i = 0; i < k; ++i) {
     val += x_temp[i];
   }
   scs_free(x_temp);
@@ -165,18 +179,23 @@ static void compute_cone_residuals(scs_float t, const scs_float *x,
   scs_float lmbda_t = t - t0;
   scs_float *lmbda_x = scs_malloc(n * sizeof(*x));
   scs_float sum_lmbda_x = 0.0;
-  for (scs_int i = 0; i < n; ++i) {
+  scs_int i;
+  scs_float comp;
+  scs_float pri_res;
+  scs_float dual_res;
+
+  for (i = 0; i < n; ++i) {
     lmbda_x[i] = x[i] - x0[i];
     sum_lmbda_x += lmbda_x[i];
   }
 
-  scs_float comp = lmbda_t * t + SCS(dot)(lmbda_x, x, n);
-  scs_float pri_res = sum_largest_val(x, n, k) - t;
+  comp = lmbda_t * t + SCS(dot)(lmbda_x, x, n);
+  pri_res = sum_largest_val(x, n, k) - t;
 
-  scs_float dual_res = fabs(sum_lmbda_x + lmbda_t * k);
+  dual_res = fabs(sum_lmbda_x + lmbda_t * k);
   dual_res *= dual_res;
 
-  for (scs_int i = 0; i < n; ++i) {
+  for (i = 0; i < n; ++i) {
     if (lmbda_x[i] > 0) {
       dual_res += lmbda_x[i] * lmbda_x[i];
     }

data/vendor/scs/src/spectral_cones/sum-largest/sum_largest_eval_cone.c

@@ -2,7 +2,9 @@
 #include "linalg.h"
 #include "scs_blas.h"
 #include "scs_types.h"
-#include "util.h" // just for timer
+#include "util.h"
+
+#include <string.h>
 
 /*
  * Spectral matrix cone projections, from "Projection onto Spectral Matrix
@@ -37,13 +39,14 @@ void BLAS(gemm)(const char *transa, const char *transb, blas_int *m,
 }
 #endif
 
-// forward declaration
+/* forward declaration */
 scs_int proj_sum_largest_cone_sorted(scs_float *t, scs_float *x, scs_int n,
                                      scs_int k);
 
 void flip(scs_float *x, int n) {
   scs_float temp;
-  for (int i = 0; i < n / 2; i++) {
+  int i;
+  for (i = 0; i < n / 2; i++) {
     temp = x[i];
     x[i] = x[n - i - 1];
     x[n - i - 1] = temp;
@@ -52,19 +55,19 @@ void flip(scs_float *x, int n) {
 
 scs_int SCS(proj_sum_largest_evals)(scs_float *tX, scs_int n, scs_int k,
                                     ScsConeWork *c) {
-  // tvX = [t, X], where X represents the lower triangular part of a matrix
-  // stored in a compact form and off-diagonal elements have been scaled by
-  // sqrt(2)
+  /*
+   * tvX = [t, X], where X represents the lower triangular part of a matrix
+   * stored in a compact form and off-diagonal elements have been scaled by
+   * sqrt(2)
+   */
   scs_float *X = tX + 1;
 
-  // ----------------------------------------------------------------------
-  //                      compute eigendecomposition
-  // ----------------------------------------------------------------------
+  /* compute eigendecomposition */
   scs_int i;
   blas_int nb = (blas_int)n;
   blas_int nb_plus_one = (blas_int)(n + 1);
   blas_int one_int = 1;
-  scs_float sqrt2 = sqrt(2.0);
+  scs_float sqrt2 = SQRTF(2.0);
   scs_float sqrt2_inv = 1.0 / sqrt2;
   scs_float *Xs = c->Xs;
   scs_float *e = c->e;
@@ -72,19 +75,26 @@ scs_int SCS(proj_sum_largest_evals)(scs_float *tX, scs_int n, scs_int k,
   scs_float *work = c->work;
   blas_int lwork = c->lwork;
   blas_int info = 0;
+  scs_int status;
+  char transN;
+  char transY;
+  scs_float one;
+  scs_float zero;
 
-  // copy lower triangular matrix into full matrix
+  /* copy lower triangular matrix into full matrix */
   for (i = 0; i < n; ++i) {
     memcpy(&(Xs[i * (n + 1)]), &(X[i * n - ((i - 1) * i) / 2]),
            (n - i) * sizeof(scs_float));
   }
 
-  // rescale diags by sqrt(2)
+  /* rescale diags by sqrt(2) */
   BLAS(scal)(&nb, &sqrt2, Xs, &nb_plus_one);
 
-  // Eigendecomposition. On exit, the lower triangular part of Xs stores
-  // the eigenvectors. The vector e stores the eigenvalues in ascending
-  // order (smallest eigenvalue first) */
+  /*
+   * Eigendecomposition. On exit, the lower triangular part of Xs stores
+   * the eigenvectors. The vector e stores the eigenvalues in ascending
+   * order (smallest eigenvalue first)
+   */
   BLAS(syev)("Vectors", "Lower", &nb, Xs, &nb, e, work, &lwork, &info);
   if (info != 0) {
     scs_printf("WARN: LAPACK syev error, info = %i\n", (int)info);
@@ -93,15 +103,15 @@ scs_int SCS(proj_sum_largest_evals)(scs_float *tX, scs_int n, scs_int k,
     }
   }
 
-  // ----------------------------------------------------------------------
-  //  Project onto spectral *vector* cone. Note that e is sqrt(2) times
-  //  the eigenvalue vector we want to project. We therefore multiply
-  //  tvX[0] by sqrt(2).
-  // ----------------------------------------------------------------------
+  /*
+   * Project onto spectral *vector* cone. Note that e is sqrt(2) times
+   * the eigenvalue vector we want to project. We therefore multiply
+   * tvX[0] by sqrt(2).
+   */
   tX[0] *= sqrt2;
   SPECTRAL_TIMING(SCS(timer) _timer; SCS(tic)(&_timer);)
   flip(e, n);
-  scs_int status = proj_sum_largest_cone_sorted(&tX[0], e, n, k);
+  status = proj_sum_largest_cone_sorted(&tX[0], e, n, k);
   flip(e, n);
   SPECTRAL_TIMING(c->tot_time_vec_cone_proj += SCS(tocq)(&_timer);)
 
@@ -109,20 +119,18 @@ scs_int SCS(proj_sum_largest_evals)(scs_float *tX, scs_int n, scs_int k,
     return status;
   }
 
-  // ----------------------------------------------------------------------
-  //             recover projection onto spectral *matrix* cone
-  // ----------------------------------------------------------------------
+  /* recover projection onto spectral *matrix* cone */
   memcpy(c->work_sum_of_largest, Xs, n * n * sizeof(*Xs));
   for (i = 0; i < n; ++i) {
     BLAS(scal)(&nb, &e[i], &Xs[i * n], &one_int);
   }
 
-  char transN = 'N';
-  char transY = 'T';
-  scs_float one = 1.0;
-  scs_float zero = 0.0;
+  transN = 'N';
+  transY = 'T';
+  one = 1.0;
+  zero = 0.0;
 
-  // it is not safe to have overlapping matrices for dgemm_.
+  /* it is not safe to have overlapping matrices for dgemm_. */
   BLAS(gemm)(&transN, &transY, &nb, &nb, &nb, &one, Xs, &nb,
              c->work_sum_of_largest, &nb, &zero, Z, &nb);
 

data/vendor/scs/src/spectral_cones/util_spectral_cones.c

@@ -1,7 +1,8 @@
 #include "util_spectral_cones.h"
 
 bool is_pos(const scs_float *x, scs_int n) {
-  for (scs_int i = 0; i < n; ++i) {
+  scs_int i;
+  for (i = 0; i < n; ++i) {
     if (x[i] <= 0.0) {
       return false;
     }
@@ -10,7 +11,8 @@ bool is_pos(const scs_float *x, scs_int n) {
 }
 
 bool is_negative(const scs_float *x, scs_int n) {
-  for (scs_int i = 0; i < n; ++i) {
+  scs_int i;
+  for (i = 0; i < n; ++i) {
     if (x[i] >= 0.0) {
       return false;
     }
@@ -19,13 +21,15 @@ bool is_negative(const scs_float *x, scs_int n) {
 }
 
 void non_neg_proj(const scs_float *src, scs_float *dst, scs_int n) {
-  for (scs_int i = 0; i < n; ++i) {
+  scs_int i;
+  for (i = 0; i < n; ++i) {
     dst[i] = (src[i] > 0.0) ? src[i] : 0.0;
   }
 }
 
 void print_vector(const scs_float *x, scs_int n) {
-  for (scs_int i = 0; i < n; ++i) {
+  scs_int i;
+  for (i = 0; i < n; ++i) {
     printf("%f ", x[i]);
   }
   printf("\n");
@@ -33,8 +37,9 @@ void print_vector(const scs_float *x, scs_int n) {
 
 scs_float min_vec(const scs_float *vec, scs_int n) {
   scs_float minVal = vec[0];
+  scs_int i;
 
-  for (scs_int i = 1; i < n; ++i) {
+  for (i = 1; i < n; ++i) {
     if (vec[i] < minVal) {
       minVal = vec[i];
     }
@@ -45,7 +50,8 @@ scs_float min_vec(const scs_float *vec, scs_int n) {
 
 scs_float sum_log(const scs_float *x, scs_int n) {
   scs_float sum = 0.0;
-  for (scs_int i = 0; i < n; ++i) {
+  scs_int i;
+  for (i = 0; i < n; ++i) {
     sum += log(x[i]);
   }
   return sum;

data/vendor/scs/src/util.c

@@ -1,6 +1,12 @@
+/*
+ * Utility functions: platform-specific timers, deep copy helpers for
+ * ScsData/ScsSettings, memory deallocation, and default settings.
+ */
+
 #include "util.h"
 
 #include "glbopts.h"
+#include <string.h>
 #include "linsys.h"
 #include "scs_matrix.h"
 
@@ -71,25 +77,38 @@ scs_float SCS(tocq)(SCS(timer) * t) {
 
 #endif
 
-void SCS(deep_copy_data)(ScsData *dest, const ScsData *src) {
+scs_int SCS(deep_copy_data)(ScsData *dest, const ScsData *src) {
+  memset(dest, 0, sizeof(*dest));
   dest->n = src->n;
   dest->m = src->m;
-  SCS(copy_matrix)(&(dest->A), src->A);
-  SCS(copy_matrix)(&(dest->P), src->P);
+  if (!SCS(copy_matrix)(&(dest->A), src->A) ||
+      !SCS(copy_matrix)(&(dest->P), src->P)) {
+    return 0;
+  }
   dest->b = (scs_float *)scs_calloc(dest->m, sizeof(scs_float));
-  memcpy(dest->b, src->b, dest->m * sizeof(scs_float));
   dest->c = (scs_float *)scs_calloc(dest->n, sizeof(scs_float));
+  if (!dest->b || !dest->c) {
+    return 0;
+  }
+  memcpy(dest->b, src->b, dest->m * sizeof(scs_float));
   memcpy(dest->c, src->c, dest->n * sizeof(scs_float));
+  return 1;
 }
 
-void SCS(deep_copy_stgs)(ScsSettings *dest, const ScsSettings *src) {
+scs_int SCS(deep_copy_stgs)(ScsSettings *dest, const ScsSettings *src) {
   memcpy(dest, src, sizeof(ScsSettings));
   /* MATLAB does something weird with strdup, so use strcpy instead */
   char *tmp;
   if (src->write_data_filename) {
     /* sizeof(char) = 1 */
     tmp = (char *)scs_malloc(strlen(src->write_data_filename) + 1);
-    strcpy(tmp, src->write_data_filename);
+    if (tmp) {
+      strcpy(tmp, src->write_data_filename);
+    }
+    if (!tmp) {
+      dest->write_data_filename = SCS_NULL;
+      return 0;
+    }
     dest->write_data_filename = tmp;
   } else {
     dest->write_data_filename = SCS_NULL;
@@ -98,11 +117,18 @@ void SCS(deep_copy_stgs)(ScsSettings *dest, const ScsSettings *src) {
   if (src->log_csv_filename) {
     /* sizeof(char) = 1 */
     tmp = (char *)scs_malloc(strlen(src->log_csv_filename) + 1);
-    strcpy(tmp, src->log_csv_filename);
+    if (tmp) {
+      strcpy(tmp, src->log_csv_filename);
+    }
+    if (!tmp) {
+      dest->log_csv_filename = SCS_NULL;
+      return 0;
+    }
     dest->log_csv_filename = tmp;
   } else {
     dest->log_csv_filename = SCS_NULL;
   }
+  return 1;
 }
 
 void SCS(free_data)(ScsData *d) {
@@ -143,7 +169,11 @@ void scs_set_default_settings(ScsSettings *stgs) {
   stgs->warm_start = WARM_START;
   stgs->acceleration_lookback = ACCELERATION_LOOKBACK;
   stgs->acceleration_interval = ACCELERATION_INTERVAL;
+  stgs->acceleration_type_1 = ACCELERATION_TYPE_1;
+  stgs->acceleration_regularization = AA_REGULARIZATION;
+  stgs->acceleration_relaxation = AA_RELAXATION;
   stgs->adaptive_scale = ADAPTIVE_SCALE;
+  stgs->adaptive_diag_scale = ADAPTIVE_DIAG_SCALE;
   stgs->write_data_filename = WRITE_DATA_FILENAME;
   stgs->log_csv_filename = LOG_CSV_FILENAME;
   stgs->time_limit_secs = TIME_LIMIT_SECS;

data/vendor/scs/test/mkl_interface_mismatch.c

@@ -0,0 +1,97 @@
+#include "scs.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* Two modes, selected by argv[1]:
+ *
+ *   mismatch (default): preset the WRONG integer width before scs_init;
+ *     initialization must fail fast with the interface-layer diagnostic.
+ *
+ *   gnu: preset the GNU Fortran calling-convention flag together with the
+ *     CORRECT integer width (values 2 = LP64|GNU or 3 = ILP64|GNU, as an
+ *     MKL-backed NumPy does when it initializes MKL first); initialization
+ *     and a full solve must succeed, proving the runtime guard compares
+ *     only the width bit. */
+
+#define MKL_INTERFACE_LP64 0
+#define MKL_INTERFACE_ILP64 1
+#define MKL_INTERFACE_GNU 2
+
+int MKL_Set_Interface_Layer(int);
+
+int main(int argc, char **argv) {
+  scs_float P_x[3] = {3., -1., 2.};
+  scs_int P_i[3] = {0, 0, 1};
+  scs_int P_p[3] = {0, 1, 3};
+  scs_float A_x[4] = {-1., 1., 1., 1.};
+  scs_int A_i[4] = {0, 1, 0, 2};
+  scs_int A_p[3] = {0, 2, 4};
+  scs_float b[3] = {-1., 0.3, -0.5};
+  scs_float c[2] = {-1., -1.};
+  ScsCone k = {0};
+  ScsData d = {0};
+  ScsSettings stgs = {0};
+  ScsSolution sol = {0};
+  ScsInfo info;
+  ScsWork *w;
+  int gnu_mode = argc > 1 && strcmp(argv[1], "gnu") == 0;
+  int layer;
+  int actual;
+  scs_int exitflag;
+
+#ifdef BLAS64
+  layer = gnu_mode ? (MKL_INTERFACE_ILP64 | MKL_INTERFACE_GNU)
+                   : MKL_INTERFACE_LP64;
+#else
+  layer = gnu_mode ? (MKL_INTERFACE_LP64 | MKL_INTERFACE_GNU)
+                   : MKL_INTERFACE_ILP64;
+#endif
+
+  actual = MKL_Set_Interface_Layer(layer);
+  if (actual != layer) {
+    fprintf(stderr,
+            "failed to pre-set MKL interface layer to %d, actual layer is %d\n",
+            layer, actual);
+    return 2;
+  }
+
+  d.m = 3;
+  d.n = 2;
+  d.b = b;
+  d.c = c;
+  d.A = &(ScsMatrix){A_x, A_i, A_p, 3, 2};
+  d.P = &(ScsMatrix){P_x, P_i, P_p, 2, 2};
+
+  k.z = 1;
+  k.l = 2;
+
+  scs_set_default_settings(&stgs);
+  stgs.verbose = 1;
+
+  if (gnu_mode) {
+    exitflag = scs(&d, &k, &stgs, &sol, &info);
+    if (exitflag != SCS_SOLVED) {
+      fprintf(stderr, "gnu-layer solve failed with exitflag %d\n",
+              (int)exitflag);
+      return 4;
+    }
+    printf("gnu-layer solve succeeded (layer %d)\n", layer);
+    free(sol.x);
+    free(sol.y);
+    free(sol.s);
+    return 0;
+  }
+
+  w = scs_init(&d, &k, &stgs);
+  if (w != SCS_NULL) {
+    fprintf(stderr,
+            "expected scs_init to fail after forcing the wrong MKL interface "
+            "layer\n");
+    scs_finish(w);
+    return 3;
+  }
+
+  return 0;
+}

data/vendor/scs/test/packaging/CMakeLists.txt

@@ -0,0 +1,21 @@
+# Consumes an INSTALLED scs package (see .github/workflows/cmake_consume.yml).
+# The installed package, not this fixture, must enforce its consumer floor.
+cmake_minimum_required(VERSION 3.18)
+project(scs_consume C)
+
+set(SCS_COMPONENT scsdir CACHE STRING "scs library to consume (scsdir, scsmkl, ...)")
+
+# CI: a consumer that resolved LAPACK at the wrong integer width before scs
+# must be refused by a static package.
+option(PREFIND_LAPACK_WRONG_WIDTH "find LAPACK with 4-byte integers first" OFF)
+if(PREFIND_LAPACK_WRONG_WIDTH)
+  set(BLA_SIZEOF_INTEGER 4)
+  find_package(LAPACK REQUIRED)
+endif()
+
+find_package(scs CONFIG REQUIRED)
+if(NOT scs::${SCS_COMPONENT} IN_LIST scs_LIBRARIES)
+  message(FATAL_ERROR "scs_LIBRARIES=${scs_LIBRARIES} lacks scs::${SCS_COMPONENT}")
+endif()
+add_executable(consume consume.c)
+target_link_libraries(consume PRIVATE scs::${SCS_COMPONENT})

data/vendor/scs/test/packaging/consume.c

@@ -0,0 +1,50 @@
+/* Minimal consumer of an *installed* SCS package: links scs::scsdir via
+ * find_package(scs) and solves a tiny QP. Used by the cmake_consume CI
+ * workflow to prove installed packages are usable for both shared and
+ * static builds (and that shared installs demand no private build deps). */
+#include "scs.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(void) {
+  scs_float P_x[3] = {3., -1., 2.};
+  scs_int P_i[3] = {0, 0, 1};
+  scs_int P_p[3] = {0, 1, 3};
+  scs_float A_x[4] = {-1., 1., 1., 1.};
+  scs_int A_i[4] = {0, 1, 0, 2};
+  scs_int A_p[3] = {0, 2, 4};
+  scs_float b[3] = {-1., 0.3, -0.5};
+  scs_float c[2] = {-1., -1.};
+  ScsCone k = {0};
+  ScsData d = {0};
+  ScsSettings stgs = {0};
+  ScsSolution sol = {0};
+  ScsInfo info;
+  scs_int exitflag;
+
+  printf("consuming scs %s\n", scs_version());
+
+  d.m = 3;
+  d.n = 2;
+  d.b = b;
+  d.c = c;
+  d.A = &(ScsMatrix){A_x, A_i, A_p, 3, 2};
+  d.P = &(ScsMatrix){P_x, P_i, P_p, 2, 2};
+  k.z = 1;
+  k.l = 2;
+
+  scs_set_default_settings(&stgs);
+  stgs.verbose = 1;
+
+  exitflag = scs(&d, &k, &stgs, &sol, &info);
+  if (exitflag != SCS_SOLVED) {
+    fprintf(stderr, "consume: solve failed with exitflag %d\n", (int)exitflag);
+    return 1;
+  }
+  printf("consume: solved, objective %f\n", info.pobj);
+  free(sol.x);
+  free(sol.y);
+  free(sol.s);
+  return 0;
+}

data/vendor/scs/test/problem_utils.h

@@ -10,6 +10,8 @@
 #include "scs_matrix.h"
 #include "util.h"
 
+#include <string.h>
+
 #define _MAX_RAND_VAL (1073741823) /* 2^30 - 1 */
 
 /* uniform random number in [-1,1] */
@@ -205,10 +207,15 @@ const char *verify_solution_correct(ScsData *d, ScsCone *k, ScsSettings *stgs,
 
   /**************** ASSERTS *****************/
   if (status == SCS_SOLVED) {
+    /* reported-vs-recomputed consistency: the recomputation here uses a
+     * different BLAS summation order than the solver's internal pipeline,
+     * so the discrepancy scales with the magnitude of the accumulated
+     * quantities (~ the objective scale), like the gap and objective
+     * checks below already do */
     mu_assert_less("Primal residual ERROR", ABS(res_pri - info->res_pri),
-                   1e-10);
+                   1e-10 * (1 + ABS(pobj)));
     mu_assert_less("Dual residual ERROR", ABS(res_dual - info->res_dual),
-                   1e-10);
+                   1e-10 * (1 + ABS(pobj)));
     mu_assert_less("Gap ERROR", ABS(gap - info->gap), 1e-7 * (1 + ABS(gap)));
     mu_assert_less("Primal obj ERROR", ABS(pobj - info->pobj),
                    1e-9 * (1 + ABS(pobj)));