scs 0.3.1 → 0.3.2

data/vendor/scs/src/scs.c

@@ -7,6 +7,7 @@
 #include "normalize.h"
 #include "rw.h"
 #include "scs_matrix.h"
+#include "scs_work.h"
 #include "util.h"
 
 /* printing header */
@@ -41,11 +42,8 @@ static void free_work(ScsWork *w) {
     scs_free(w->g);
     scs_free(w->b_normalized);
     scs_free(w->c_normalized);
-    scs_free(w->rho_y_vec);
     scs_free(w->lin_sys_warm_start);
-    if (w->cone_boundaries) {
-      scs_free(w->cone_boundaries);
-    }
+    scs_free(w->diag_r);
     if (w->scal) {
       scs_free(w->scal->D);
       scs_free(w->scal->E);
@@ -53,7 +51,7 @@ static void free_work(ScsWork *w) {
     }
     SCS(free_sol)(w->xys_orig);
     free_residuals(w->r_orig);
-    if (w->stgs->normalize) {
+    if (w->stgs && w->stgs->normalize) {
       SCS(free_sol)(w->xys_normalized);
       free_residuals(w->r_normalized);
     }
@@ -78,7 +76,7 @@ static void print_init_header(const ScsData *d, const ScsCone *k,
   }
   scs_printf("\n\t       SCS v%s - Splitting Conic Solver\n\t(c) Brendan "
              "O'Donoghue, Stanford University, 2012\n",
-             SCS(version)());
+             scs_version());
   for (i = 0; i < LINE_LEN; ++i) {
     scs_printf("-");
   }
@@ -157,23 +155,22 @@ static scs_int failure(ScsWork *w, scs_int m, scs_int n, ScsSolution *sol,
 }
 
 /* given x,y,s warm start, set v = [x; s / R + y; 1]
- * where R = diag(w->rho_y_vec).
  */
 static void warm_start_vars(ScsWork *w, ScsSolution *sol) {
   scs_int n = w->n, m = w->m, i;
   scs_float *v = w->v;
   /* normalize the warm-start */
   if (w->stgs->normalize) {
-    SCS(normalize_sol)(w, sol);
+    SCS(normalize_sol)(w->scal, sol);
   }
   memcpy(v, sol->x, n * sizeof(scs_float));
   for (i = 0; i < m; ++i) {
-    v[i + n] = sol->y[i] + sol->s[i] / w->rho_y_vec[i];
+    v[i + n] = sol->y[i] + sol->s[i] / w->diag_r[i + n];
   }
   v[n + m] = 1.0; /* tau = 1 */
   /* un-normalize so sol unchanged */
   if (w->stgs->normalize) {
-    SCS(un_normalize_sol)(w, sol);
+    SCS(un_normalize_sol)(w->scal, sol);
   }
 }
 
@@ -221,12 +218,12 @@ static void unnormalize_residuals(ScsWork *w) {
   r->dobj = r_n->dobj / pd;
   r->gap = r_n->gap / pd;
 
-  SCS(un_normalize_primal)(w, r->ax);
-  SCS(un_normalize_primal)(w, r->ax_s);
-  SCS(un_normalize_primal)(w, r->ax_s_btau);
-  SCS(un_normalize_dual)(w, r->aty);
-  SCS(un_normalize_dual)(w, r->px);
-  SCS(un_normalize_dual)(w, r->px_aty_ctau);
+  SCS(un_normalize_primal)(w->scal, r->ax);
+  SCS(un_normalize_primal)(w->scal, r->ax_s);
+  SCS(un_normalize_primal)(w->scal, r->ax_s_btau);
+  SCS(un_normalize_dual)(w->scal, r->aty);
+  SCS(un_normalize_dual)(w->scal, r->px);
+  SCS(un_normalize_dual)(w->scal, r->px_aty_ctau);
 
   compute_residuals(r, w->m, w->n);
 }
@@ -306,7 +303,7 @@ static void populate_residual_struct(ScsWork *w, scs_int iter) {
     memcpy(w->xys_orig->x, w->xys_normalized->x, n * sizeof(scs_float));
     memcpy(w->xys_orig->y, w->xys_normalized->y, m * sizeof(scs_float));
     memcpy(w->xys_orig->s, w->xys_normalized->s, m * sizeof(scs_float));
-    SCS(un_normalize_sol)(w, w->xys_orig);
+    SCS(un_normalize_sol)(w->scal, w->xys_orig);
     unnormalize_residuals(w);
   }
 }
@@ -317,47 +314,34 @@ static void cold_start_vars(ScsWork *w) {
   w->v[l - 1] = 1.;
 }
 
-/* utility function that scales first n entries in inner prod by rho_x   */
-/* and last m entries by 1 / rho_y_vec, assumes length of array is n + m */
-/* See .note_on_scale in repo for explanation */
-static scs_float dot_with_diag_scaling(ScsWork *w, const scs_float *x,
-                                       const scs_float *y) {
-  scs_int i, n = w->n, len = w->n + w->m;
+/* utility function that computes x'Ry */
+static inline scs_float dot_r(ScsWork *w, const scs_float *x,
+                              const scs_float *y) {
+  scs_int i;
   scs_float ip = 0.0;
-  for (i = 0; i < n; ++i) {
-    ip += w->stgs->rho_x * x[i] * y[i];
-  }
-  for (i = n; i < len; ++i) {
-    ip += x[i] * y[i] * w->rho_y_vec[i - n];
+  for (i = 0; i < w->n + w->m; ++i) {
+    ip += x[i] * y[i] * w->diag_r[i];
   }
   return ip;
 }
 
-static inline scs_float get_tau_scale(ScsWork *w) {
-  return TAU_FACTOR; /* TAU_FACTOR * w->scale; */
-}
-
 static scs_float root_plus(ScsWork *w, scs_float *p, scs_float *mu,
                            scs_float eta) {
-  scs_float b, c, tau, a, tau_scale;
-  tau_scale = get_tau_scale(w);
-  a = tau_scale + dot_with_diag_scaling(w, w->g, w->g);
-  b = (dot_with_diag_scaling(w, mu, w->g) -
-       2 * dot_with_diag_scaling(w, p, w->g) - eta * tau_scale);
-  c = dot_with_diag_scaling(w, p, p) - dot_with_diag_scaling(w, p, mu);
-  tau = (-b + SQRTF(MAX(b * b - 4 * a * c, 0.))) / (2 * a);
-  return tau;
+  scs_float a, b, c, tau_scale = w->diag_r[w->n + w->m];
+  a = tau_scale + dot_r(w, w->g, w->g);
+  b = dot_r(w, mu, w->g) - 2 * dot_r(w, p, w->g) - eta * tau_scale;
+  c = dot_r(w, p, p) - dot_r(w, p, mu);
+  return (-b + SQRTF(MAX(b * b - 4 * a * c, 0.))) / (2 * a);
 }
 
 /* status < 0 indicates failure */
 static scs_int project_lin_sys(ScsWork *w, scs_int iter) {
   scs_int n = w->n, m = w->m, l = n + m + 1, status, i;
   scs_float *warm_start = SCS_NULL;
-  scs_float tol = -1.0; /* only used for indirect methods, overriden later */
+  scs_float tol = -1.0; /* only used for indirect methods, overridden later */
   memcpy(w->u_t, w->v, l * sizeof(scs_float));
-  SCS(scale_array)(w->u_t, w->stgs->rho_x, n);
-  for (i = n; i < l - 1; ++i) {
-    w->u_t[i] *= -w->rho_y_vec[i - n];
+  for (i = 0; i < l - 1; ++i) {
+    w->u_t[i] *= (i < n ? 1 : -1) * w->diag_r[i];
   }
 #if INDIRECT > 0
   /* compute warm start using the cone projection output */
@@ -395,28 +379,15 @@ static scs_int project_lin_sys(ScsWork *w, scs_int iter) {
  */
 static void compute_rsk(ScsWork *w) {
   scs_int i, l = w->m + w->n + 1;
-  /* r, should = 0 so skip */
-  /*
-  for (i = 0; i < w->n; ++i) {
-    w->rsk[i] = w->stgs->rho_x * (w->v[i] + w->u[i] - 2 * w->u_t[i]);
-  }
-  */
-  /* s */
-  for (i = w->n; i < l - 1; ++i) {
-    w->rsk[i] = (w->v[i] + w->u[i] - 2 * w->u_t[i]) * w->rho_y_vec[i - w->n];
+  for (i = 0; i < l; ++i) {
+    w->rsk[i] = (w->v[i] + w->u[i] - 2 * w->u_t[i]) * w->diag_r[i];
   }
-  /* kappa, incorporates tau scaling parameter */
-  w->rsk[l - 1] =
-      get_tau_scale(w) * (w->v[l - 1] + w->u[l - 1] - 2 * w->u_t[l - 1]);
 }
 
 static void update_dual_vars(ScsWork *w) {
   scs_int i, l = w->n + w->m + 1;
-  scs_float a = w->stgs->alpha;
-  /* compute and store [r;s;kappa] */
-  compute_rsk(w);
   for (i = 0; i < l; ++i) {
-    w->v[i] += a * (w->u[i] - w->u_t[i]);
+    w->v[i] += w->stgs->alpha * (w->u[i] - w->u_t[i]);
   }
 }
 
@@ -427,7 +398,8 @@ static scs_int project_cones(ScsWork *w, const ScsCone *k, scs_int iter) {
     w->u[i] = 2 * w->u_t[i] - w->v[i];
   }
   /* u = [x;y;tau] */
-  status = SCS(proj_dual_cone)(&(w->u[n]), k, w->cone_work, w->stgs->normalize);
+  status =
+      SCS(proj_dual_cone)(&(w->u[n]), w->cone_work, w->scal, &(w->diag_r[n]));
   if (iter < FEASIBLE_ITERS) {
     w->u[l - 1] = 1.0;
   } else {
@@ -526,7 +498,7 @@ static void finalize(ScsWork *w, ScsSolution *sol, ScsInfo *info,
   sety(w, sol);
   sets(w, sol);
   if (w->stgs->normalize) {
-    SCS(un_normalize_sol)(w, sol);
+    SCS(un_normalize_sol)(w->scal, sol);
   }
   populate_residual_struct(w, iter);
   info->setup_time = w->setup_time;
@@ -578,6 +550,7 @@ static void print_summary(ScsWork *w, scs_int i, SCS(timer) * solve_timer) {
   scs_printf("Norm u = %4f, ", SCS(norm_2)(w->u, w->n + w->m + 1));
   scs_printf("Norm u_t = %4f, ", SCS(norm_2)(w->u_t, w->n + w->m + 1));
   scs_printf("Norm v = %4f, ", SCS(norm_2)(w->v, w->n + w->m + 1));
+  scs_printf("Norm rsk = %4f, ", SCS(norm_2)(w->rsk, w->n + w->m + 1));
   scs_printf("Norm x = %4f, ", SCS(norm_2)(w->xys_orig->x, w->n));
   scs_printf("Norm y = %4f, ", SCS(norm_2)(w->xys_orig->y, w->m));
   scs_printf("Norm s = %4f, ", SCS(norm_2)(w->xys_orig->s, w->m));
@@ -739,6 +712,10 @@ static scs_int validate(const ScsData *d, const ScsCone *k,
     scs_printf("scale must be positive (1 works well).\n");
     return -1;
   }
+  if (stgs->acceleration_interval <= 0) {
+    scs_printf("acceleration_interval must be positive (10 works well).\n");
+    return -1;
+  }
   return 0;
 }
 #endif
@@ -755,6 +732,18 @@ static ScsResiduals *init_residuals(const ScsData *d) {
   return r;
 }
 
+/* Sets the diag_r vector, given the scale parameters in work */
+static void set_diag_r(ScsWork *w) {
+  scs_int i;
+  for (i = 0; i < w->n; ++i) {
+    w->diag_r[i] = w->stgs->rho_x;
+  }
+  /* use cone information to set R_y */
+  SCS(set_r_y)(w->cone_work, w->scale, &(w->diag_r[w->n]));
+  /* if modified need to SCS(enforce_cone_boundaries)(...) */
+  w->diag_r[w->n + w->m] = TAU_FACTOR; /* TODO: is this the best choice? */
+}
+
 static ScsWork *init_work(const ScsData *d, const ScsCone *k,
                           const ScsSettings *stgs) {
   ScsWork *w = (ScsWork *)scs_calloc(1, sizeof(ScsWork));
@@ -787,7 +776,7 @@ static ScsWork *init_work(const ScsData *d, const ScsCone *k,
   w->h = (scs_float *)scs_calloc((l - 1), sizeof(scs_float));
   w->g = (scs_float *)scs_calloc((l - 1), sizeof(scs_float));
   w->lin_sys_warm_start = (scs_float *)scs_calloc((l - 1), sizeof(scs_float));
-  w->rho_y_vec = (scs_float *)scs_calloc(d->m, sizeof(scs_float));
+  w->diag_r = (scs_float *)scs_calloc(l, sizeof(scs_float));
   /* x,y,s struct */
   w->xys_orig = (ScsSolution *)scs_calloc(1, sizeof(ScsSolution));
   w->xys_orig->x = (scs_float *)scs_calloc(d->n, sizeof(scs_float));
@@ -804,7 +793,12 @@ static ScsWork *init_work(const ScsData *d, const ScsCone *k,
   w->c_normalized = (scs_float *)scs_calloc(d->n, sizeof(scs_float));
   memcpy(w->b_normalized, w->b_orig, w->m * sizeof(scs_float));
   memcpy(w->c_normalized, w->c_orig, w->n * sizeof(scs_float));
-  SCS(set_rho_y_vec)(k, w->scale, w->rho_y_vec, w->m);
+
+  if (!(w->cone_work = SCS(init_cone)(k, w->m))) {
+    scs_printf("ERROR: init_cone failure\n");
+    return SCS_NULL;
+  }
+  set_diag_r(w);
 
   if (!w->c_normalized) {
     scs_printf("ERROR: work memory allocation failure\n");
@@ -829,24 +823,14 @@ static ScsWork *init_work(const ScsData *d, const ScsCone *k,
     }
 #endif
     /* this allocates memory that must be freed */
-    w->cone_boundaries_len = SCS(set_cone_boundaries)(k, &w->cone_boundaries);
-    w->scal = (ScsScaling *)scs_calloc(1, sizeof(ScsScaling));
-    SCS(normalize)
-    (w->P, w->A, w->b_normalized, w->c_normalized, w->scal, w->cone_boundaries,
-     w->cone_boundaries_len);
+    w->scal = SCS(normalize_a_p)(w->P, w->A, w->b_normalized, w->c_normalized,
+                                 w->cone_work);
   } else {
     w->xys_normalized = w->xys_orig;
     w->r_normalized = w->r_orig;
-    w->cone_boundaries_len = 0;
-    w->cone_boundaries = SCS_NULL;
     w->scal = SCS_NULL;
   }
-  if (!(w->cone_work = SCS(init_cone)(k, w->scal, w->m))) {
-    scs_printf("ERROR: init_cone failure\n");
-    return SCS_NULL;
-  }
-  if (!(w->p =
-            SCS(init_lin_sys_work)(w->A, w->P, w->rho_y_vec, w->stgs->rho_x))) {
+  if (!(w->p = SCS(init_lin_sys_work)(w->A, w->P, w->diag_r))) {
     scs_printf("ERROR: init_lin_sys_work failure\n");
     return SCS_NULL;
   }
@@ -898,11 +882,11 @@ static scs_int update_work(const ScsData *d, ScsWork *w, ScsSolution *sol) {
 }
 
 /* will update if the factor is outside of range */
-scs_int should_update_rho_y_vec(scs_float factor, scs_int iter) {
+scs_int should_update_r(scs_float factor, scs_int iter) {
   return (factor > SQRTF(10.) || factor < 1. / SQRTF(10.));
 }
 
-static void maybe_update_scale(ScsWork *w, const ScsCone *k, scs_int iter) {
+static void update_scale(ScsWork *w, const ScsCone *k, scs_int iter) {
   scs_int i;
   scs_float factor, new_scale;
 
@@ -939,14 +923,18 @@ static void maybe_update_scale(ScsWork *w, const ScsCone *k, scs_int iter) {
   if (new_scale == w->scale) {
     return;
   }
-  if (should_update_rho_y_vec(factor, iters_since_last_update)) {
+  if (should_update_r(factor, iters_since_last_update)) {
     w->scale_updates++;
     w->sum_log_scale_factor = 0;
     w->n_log_scale_factor = 0;
     w->last_scale_update_iter = iter;
     w->scale = new_scale;
-    SCS(set_rho_y_vec)(k, w->scale, w->rho_y_vec, w->m);
-    SCS(update_lin_sys_rho_y_vec)(w->p, w->rho_y_vec);
+
+    /* update diag r vector */
+    set_diag_r(w);
+
+    /* update linear systems */
+    SCS(update_lin_sys_diag_r)(w->p, w->diag_r);
 
     /* update pre-solved quantities */
     update_work_cache(w);
@@ -956,10 +944,11 @@ static void maybe_update_scale(ScsWork *w, const ScsCone *k, scs_int iter) {
       aa_reset(w->accel);
     }
     /* update v, using fact that rsk, u, u_t vectors should be the same */
-    /* solve: R (v^+ + u - 2u_t) = rsk => v^+ = R^-1 rsk + 2u_t - u  */
-    /* only elements with scale on diag */
-    for (i = w->n; i < w->n + w->m; i++) {
-      w->v[i] = w->rsk[i] / w->rho_y_vec[i - w->n] + 2 * w->u_t[i] - w->u[i];
+    /* solve: R^+ (v^+ + u - 2u_t) = rsk = R(v + u - 2u_t)
+     *  => v^+ = R+^-1 rsk + 2u_t - u
+     */
+    for (i = 0; i < w->n + w->m + 1; i++) {
+      w->v[i] = w->rsk[i] / w->diag_r[i] + 2 * w->u_t[i] - w->u[i];
     }
   }
 }
@@ -970,7 +959,7 @@ static inline void normalize_v(scs_float *v, scs_int len) {
   SCS(scale_array)(v, SQRTF((scs_float)len) * ITERATE_NORM / v_norm, len);
 }
 
-scs_int SCS(solve)(ScsWork *w, ScsSolution *sol, ScsInfo *info) {
+scs_int scs_solve(ScsWork *w, ScsSolution *sol, ScsInfo *info) {
   scs_int i;
   SCS(timer) solve_timer, lin_sys_timer, cone_timer, accel_timer;
   scs_float total_accel_time = 0.0, total_cone_time = 0.0,
@@ -986,6 +975,7 @@ scs_int SCS(solve)(ScsWork *w, ScsSolution *sol, ScsInfo *info) {
   /* initialize ctrl-c support */
   scs_start_interrupt_listener();
   SCS(tic)(&solve_timer);
+  strcpy(info->lin_sys_solver, SCS(get_lin_sys_method)());
   info->status_val = SCS_UNFINISHED; /* not yet converged */
   update_work(d, w, sol);
 
@@ -1015,7 +1005,7 @@ scs_int SCS(solve)(ScsWork *w, ScsSolution *sol, ScsInfo *info) {
     /* store v_prev = v, *after* normalizing */
     memcpy(w->v_prev, w->v, l * sizeof(scs_float));
 
-    /* linear system solve */
+    /******************* linear system solve ********************/
     SCS(tic)(&lin_sys_timer);
     if (project_lin_sys(w, i) < 0) {
       return failure(w, w->m, w->n, sol, info, SCS_FAILED,
@@ -1023,7 +1013,7 @@ scs_int SCS(solve)(ScsWork *w, ScsSolution *sol, ScsInfo *info) {
     }
     total_lin_sys_time += SCS(tocq)(&lin_sys_timer);
 
-    /* project onto the cones */
+    /****************** project onto the cones ******************/
     SCS(tic)(&cone_timer);
     if (project_cones(w, k, i) < 0) {
       return failure(w, w->m, w->n, sol, info, SCS_FAILED,
@@ -1031,8 +1021,9 @@ scs_int SCS(solve)(ScsWork *w, ScsSolution *sol, ScsInfo *info) {
     }
     total_cone_time += SCS(tocq)(&cone_timer);
 
-    /* dual variable step */
-    update_dual_vars(w);
+    /* compute [r;s;kappa], must be before dual var update */
+    /* since Moreau decomp logic relies on v at start */
+    compute_rsk(w);
 
     if (i % CONVERGED_INTERVAL == 0) {
       if (scs_is_interrupted()) {
@@ -1051,6 +1042,21 @@ scs_int SCS(solve)(ScsWork *w, ScsSolution *sol, ScsInfo *info) {
       }
     }
 
+    /* Compute residuals. */
+    if (w->stgs->verbose && i % PRINT_INTERVAL == 0) {
+      populate_residual_struct(w, i);
+      print_summary(w, i, &solve_timer);
+    }
+
+    /* If residuals are fresh then maybe compute new scale. */
+    if (w->stgs->adaptive_scale && i == w->r_orig->last_iter) {
+      update_scale(w, k, i);
+    }
+
+    /****************** dual variable step **********************/
+    /* do this after update_scale due to remapping that happens there */
+    update_dual_vars(w);
+
     /* AA safeguard check.
      * Perform safeguarding *after* convergence check to prevent safeguard
      * overwriting converged iterate, since safeguard is on `v` and convergence
@@ -1066,17 +1072,6 @@ scs_int SCS(solve)(ScsWork *w, ScsSolution *sol, ScsInfo *info) {
       }
     }
 
-    /* Compute residuals. */
-    if (w->stgs->verbose && i % PRINT_INTERVAL == 0) {
-      populate_residual_struct(w, i);
-      print_summary(w, i, &solve_timer);
-    }
-
-    /* If residuals are fresh then maybe compute new scale. */
-    if (w->stgs->adaptive_scale && i == w->r_orig->last_iter) {
-      maybe_update_scale(w, k, i);
-    }
-
     /* Log *after* updating scale so residual recalc does not affect alg */
     if (w->stgs->log_csv_filename) {
       /* calc residuals every iter if logging to csv */
@@ -1113,12 +1108,12 @@ scs_int SCS(solve)(ScsWork *w, ScsSolution *sol, ScsInfo *info) {
   return info->status_val;
 }
 
-void SCS(finish)(ScsWork *w) {
+void scs_finish(ScsWork *w) {
   if (w) {
     SCS(finish_cone)(w->cone_work);
     if (w->stgs && w->stgs->normalize) {
 #ifndef COPYAMATRIX
-      SCS(un_normalize)(w->A, w->P, w->scal);
+      SCS(un_normalize_a_p)(w->A, w->P, w->scal);
 #else
       SCS(free_scs_matrix)(w->A);
       SCS(free_scs_matrix)(w->P);
@@ -1134,8 +1129,7 @@ void SCS(finish)(ScsWork *w) {
   }
 }
 
-ScsWork *SCS(init)(const ScsData *d, const ScsCone *k,
-                   const ScsSettings *stgs) {
+ScsWork *scs_init(const ScsData *d, const ScsCone *k, const ScsSettings *stgs) {
   ScsWork *w;
   SCS(timer) init_timer;
   scs_start_interrupt_listener();
@@ -1161,22 +1155,22 @@ ScsWork *SCS(init)(const ScsData *d, const ScsCone *k,
   return w;
 }
 
-/* this just calls SCS(init), SCS(solve), and SCS(finish) */
+/* this just calls scs_init, scs_solve, and scs_finish */
 scs_int scs(const ScsData *d, const ScsCone *k, const ScsSettings *stgs,
             ScsSolution *sol, ScsInfo *info) {
   scs_int status;
-  ScsWork *w = SCS(init)(d, k, stgs);
+  ScsWork *w = scs_init(d, k, stgs);
 #if VERBOSITY > 0
   scs_printf("size of scs_int = %lu, size of scs_float = %lu\n",
              sizeof(scs_int), sizeof(scs_float));
 #endif
   if (w) {
-    SCS(solve)(w, sol, info);
+    scs_solve(w, sol, info);
     status = info->status_val;
   } else {
     status = failure(SCS_NULL, d ? d->m : -1, d ? d->n : -1, sol, info,
                      SCS_FAILED, "could not initialize work", "failure");
   }
-  SCS(finish)(w);
+  scs_finish(w);
   return status;
 }

data/vendor/scs/src/scs_version.c

@@ -1,11 +1,13 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include "glbopts.h"
 
-const char *SCS(version)(void) {
+const char *scs_version(void) {
   return SCS_VERSION;
 }
-size_t SCS(sizeof_int)(void) {
-  return sizeof(scs_int);
-}
-size_t SCS(sizeof_float)(void) {
-  return sizeof(scs_float);
+
+#ifdef __cplusplus
 }
+#endif

data/vendor/scs/src/util.c

@@ -106,7 +106,7 @@ void SCS(free_sol)(ScsSolution *sol) {
 }
 
 /* assumes stgs already allocated memory */
-void SCS(set_default_settings)(ScsSettings *stgs) {
+void scs_set_default_settings(ScsSettings *stgs) {
   /* These constants are defined in include/glbopts.h */
   stgs->max_iters = MAX_ITERS;
   stgs->eps_abs = EPS_ABS;

data/vendor/scs/test/minunit.h

@@ -13,10 +13,15 @@
     if (!(test))                                                               \
       return message;                                                          \
   } while (0)
-#define mu_run_test(test)                                                      \
+#define mu_run_test(test) _mu_run_test(#test, test)
+
+#define _mu_run_test(name, test)                                               \
   do {                                                                         \
+    scs_printf("*********************************************************\n"); \
+    scs_printf("Running test: %s\n", name);                                    \
     const char *message = test();                                              \
     tests_run++;                                                               \
+    scs_printf("*********************************************************\n"); \
     if (message)                                                               \
       return message;                                                          \
   } while (0)

data/vendor/scs/test/problem_utils.h

@@ -10,21 +10,11 @@
 #include "scs_matrix.h"
 #include "util.h"
 
-#define PI (3.141592654)
-#ifdef DLONG
-#ifdef _WIN64
-/* this is a Microsoft extension, but also works with min_g_w-w64 */
-#define INTRW "%I64d"
-#else
-#define INTRW "%ld"
-#endif
-#else
-#define INTRW "%i"
-#endif
+#define _MAX_RAND_VAL (1073741823) /* 2^30 - 1 */
 
 /* uniform random number in [-1,1] */
 static scs_float rand_scs_float(void) {
-  return 2 * (((scs_float)ran_arr_next()) / RAND_MAX) - 1;
+  return 2 * (((scs_float)ran_arr_next()) / _MAX_RAND_VAL) - 1; /* in [-1, 1] */
 }
 
 void gen_random_prob_data(scs_int nnz, scs_int col_nnz, ScsData *d, ScsCone *k,
@@ -51,8 +41,8 @@ void gen_random_prob_data(scs_int nnz, scs_int col_nnz, ScsData *d, ScsCone *k,
   for (i = 0; i < m; i++) {
     y[i] = z[i] = rand_scs_float();
   }
-  tmp_cone_work = SCS(init_cone)(k, SCS_NULL, m);
-  SCS(proj_dual_cone)(y, k, tmp_cone_work, 0);
+  tmp_cone_work = SCS(init_cone)(k, m);
+  SCS(proj_dual_cone)(y, tmp_cone_work, SCS_NULL, SCS_NULL);
   SCS(finish_cone(tmp_cone_work));
 
   for (i = 0; i < m; i++) {
@@ -88,25 +78,25 @@ void gen_random_prob_data(scs_int nnz, scs_int col_nnz, ScsData *d, ScsCone *k,
   scs_free(z);
 }
 
-static scs_float get_dual_cone_dist(const scs_float *y, const ScsCone *k,
-                                    ScsConeWork *c, scs_int m) {
+static scs_float get_dual_cone_dist(const scs_float *y, ScsConeWork *c,
+                                    scs_int m) {
   scs_float dist;
   scs_float *t = (scs_float *)scs_calloc(m, sizeof(scs_float));
   memcpy(t, y, m * sizeof(scs_float));
-  SCS(proj_dual_cone)(t, k, c, 0);
+  SCS(proj_dual_cone)(t, c, SCS_NULL, SCS_NULL);
   dist = SCS(norm_inf_diff)(t, y, m);
   scs_free(t);
   return dist;
 }
 
 /* via moreau */
-static scs_float get_pri_cone_dist(const scs_float *s, const ScsCone *k,
-                                   ScsConeWork *c, scs_int m) {
+static scs_float get_pri_cone_dist(const scs_float *s, ScsConeWork *c,
+                                   scs_int m) {
   scs_float dist;
   scs_float *t = (scs_float *)scs_calloc(m, sizeof(scs_float));
   memcpy(t, s, m * sizeof(scs_float));
   SCS(scale_array)(t, -1.0, m);
-  SCS(proj_dual_cone)(t, k, c, 0);
+  SCS(proj_dual_cone)(t, c, SCS_NULL, SCS_NULL);
   dist = SCS(norm_inf)(t, m); /* ||s - Pi_c(s)|| = ||Pi_c*(-s)|| */
   scs_free(t);
   return dist;
@@ -123,11 +113,11 @@ const char *verify_solution_correct(ScsData *d, ScsCone *k, ScsSettings *stgs,
   scs_float *c = d->c;
   scs_float *b = d->b;
 
-  scs_float *primal = scs_calloc(m, sizeof(scs_float));
-  scs_float *ax = scs_calloc(m, sizeof(scs_float));
-  scs_float *dual = scs_calloc(n, sizeof(scs_float));
-  scs_float *px = scs_calloc(n, sizeof(scs_float));
-  scs_float *aty = scs_calloc(n, sizeof(scs_float));
+  scs_float *primal = (scs_float *)scs_calloc(m, sizeof(scs_float));
+  scs_float *ax = (scs_float *)scs_calloc(m, sizeof(scs_float));
+  scs_float *dual = (scs_float *)scs_calloc(n, sizeof(scs_float));
+  scs_float *px = (scs_float *)scs_calloc(n, sizeof(scs_float));
+  scs_float *aty = (scs_float *)scs_calloc(n, sizeof(scs_float));
 
   scs_float res_pri, res_dual, res_infeas, res_unbdd_a, res_unbdd_p;
   scs_float ctx, bty, xt_p_x, gap, pobj, dobj, sty;
@@ -135,7 +125,7 @@ const char *verify_solution_correct(ScsData *d, ScsCone *k, ScsSettings *stgs,
 
   scs_float sdist = NAN, ydist = NAN;
 
-  ScsConeWork *cone_work = SCS(init_cone)(k, SCS_NULL, m);
+  ScsConeWork *cone_work = SCS(init_cone)(k, m);
 
   /**************** PRIMAL *********************/
   memset(ax, 0, m * sizeof(scs_float));
@@ -182,10 +172,10 @@ const char *verify_solution_correct(ScsData *d, ScsCone *k, ScsSettings *stgs,
   /**************** CONES *****************/
 
   if (status == SCS_SOLVED || status == SCS_UNBOUNDED) {
-    sdist = get_pri_cone_dist(sol->s, k, cone_work, m);
+    sdist = get_pri_cone_dist(sol->s, cone_work, m);
   }
   if (status == SCS_SOLVED || status == SCS_INFEASIBLE) {
-    ydist = get_dual_cone_dist(sol->y, k, cone_work, m);
+    ydist = get_dual_cone_dist(sol->y, cone_work, m);
   }
 
   /**************** OTHERS *****************/
@@ -215,14 +205,17 @@ const char *verify_solution_correct(ScsData *d, ScsCone *k, ScsSettings *stgs,
   /**************** ASSERTS *****************/
   if (status == SCS_SOLVED) {
     mu_assert_less("Primal residual ERROR", ABS(res_pri - info->res_pri),
-                   1e-12);
+                   1e-11);
     mu_assert_less("Dual residual ERROR", ABS(res_dual - info->res_dual),
-                   1e-12);
-    mu_assert_less("Gap ERROR", ABS(gap - info->gap), 1e-12);
-    mu_assert_less("Primal obj ERROR", ABS(pobj - info->pobj), 1e-12);
-    mu_assert_less("Dual obj ERROR", ABS(dobj - info->dobj), 1e-12);
+                   1e-11);
+    mu_assert_less("Gap ERROR", ABS(gap - info->gap), 1e-8 * (1 + ABS(gap)));
+    mu_assert_less("Primal obj ERROR", ABS(pobj - info->pobj),
+                   1e-9 * (1 + ABS(pobj)));
+    mu_assert_less("Dual obj ERROR", ABS(dobj - info->dobj),
+                   1e-9 * (1 + ABS(dobj)));
     /* slightly looser tol */
-    mu_assert_less("Complementary slackness ERROR", ABS(sty), 1e-6);
+    mu_assert_less("Complementary slackness ERROR", ABS(sty),
+                   1e-8 * MAX(NORM(s, m), NORM(y, m)));
     mu_assert_less("s cone dist ERROR", ABS(sdist), 1e-5);
     mu_assert_less("y cone dist ERROR", ABS(ydist), 1e-5);
 
@@ -230,7 +223,7 @@ const char *verify_solution_correct(ScsData *d, ScsCone *k, ScsSettings *stgs,
                    stgs->eps_abs + stgs->eps_rel * prl);
     mu_assert_less("Dual feas ERROR", res_dual,
                    stgs->eps_abs + stgs->eps_rel * drl);
-    mu_assert_less("Gap ERROR", gap, stgs->eps_abs + stgs->eps_rel * grl);
+    mu_assert_less("Gap feas ERROR", gap, stgs->eps_abs + stgs->eps_rel * grl);
 
   } else if (status == SCS_INFEASIBLE) {
     mu_assert_less("Infeas ERROR", ABS(res_infeas - info->res_infeas), 1e-8);

data/vendor/scs/test/problems/degenerate.h

@@ -58,7 +58,7 @@ static const char *degenerate(void) {
   d->P->i = Pi;
   d->P->p = Pp;
 
-  SCS(set_default_settings)(stgs);
+  scs_set_default_settings(stgs);
   stgs->eps_abs = 1e-6;
   stgs->eps_rel = 1e-6;
   stgs->eps_infeas = 1e-9;