scs 0.4.0 → 0.4.1

data/vendor/scs/src/scs.c

@@ -76,7 +76,7 @@ static void print_init_header(const ScsData *d, const ScsCone *k,
                               const ScsSettings *stgs) {
   scs_int i;
   char *cone_str = SCS(get_cone_header)(k);
-  const char *lin_sys_method = SCS(get_lin_sys_method)();
+  const char *lin_sys_method = scs_get_lin_sys_method();
 #ifdef USE_LAPACK
   scs_int acceleration_lookback = stgs->acceleration_lookback;
   scs_int acceleration_interval = stgs->acceleration_interval;
@@ -195,17 +195,24 @@ static void warm_start_vars(ScsWork *w, ScsSolution *sol) {
 }
 
 static void compute_residuals(ScsResiduals *r, scs_int m, scs_int n) {
-  r->res_pri = SAFEDIV_POS(NORM(r->ax_s_btau, m), r->tau);
-  r->res_dual = SAFEDIV_POS(NORM(r->px_aty_ctau, n), r->tau);
+  scs_float nm_ax_s, nm_px, nm_aty;
+  scs_float nm_ax_s_btau = NORM(r->ax_s_btau, m);
+  scs_float nm_px_aty_ctau = NORM(r->px_aty_ctau, n);
+
+  r->res_pri = SAFEDIV_POS(nm_ax_s_btau, r->tau);
+  r->res_dual = SAFEDIV_POS(nm_px_aty_ctau, r->tau);
   r->res_unbdd_a = NAN;
   r->res_unbdd_p = NAN;
   r->res_infeas = NAN;
   if (r->ctx_tau < 0) {
-    r->res_unbdd_a = SAFEDIV_POS(NORM(r->ax_s, m), -r->ctx_tau);
-    r->res_unbdd_p = SAFEDIV_POS(NORM(r->px, n), -r->ctx_tau);
+    nm_ax_s = NORM(r->ax_s, m);
+    nm_px = NORM(r->px, n);
+    r->res_unbdd_a = SAFEDIV_POS(nm_ax_s, -r->ctx_tau);
+    r->res_unbdd_p = SAFEDIV_POS(nm_px, -r->ctx_tau);
   }
   if (r->bty_tau < 0) {
-    r->res_infeas = SAFEDIV_POS(NORM(r->aty, n), -r->bty_tau);
+    nm_aty = NORM(r->aty, n);
+    r->res_infeas = SAFEDIV_POS(nm_aty, -r->bty_tau);
   }
 }
 
@@ -347,14 +354,15 @@ static inline scs_float dot_r(ScsWork *w, const scs_float *x,
 
 static scs_float root_plus(ScsWork *w, scs_float *p, scs_float *mu,
                            scs_float eta) {
-  scs_float a, b, c, tau_scale = w->diag_r[w->d->n + w->d->m];
+  scs_float a, b, c, rad, tau_scale = w->diag_r[w->d->n + w->d->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);
+  rad = b * b - 4 * a * c;
+  return (-b + SQRTF(MAX(rad, 0.))) / (2 * a);
 }
 
-/* status < 0 indicates failure */
+/* status != 0 indicates failure */
 static scs_int project_lin_sys(ScsWork *w, scs_int iter) {
   scs_int n = w->d->n, m = w->d->m, l = n + m + 1, status, i;
   scs_float *warm_start = SCS_NULL;
@@ -364,22 +372,24 @@ static scs_int project_lin_sys(ScsWork *w, scs_int iter) {
     w->u_t[i] *= (i < n ? 1 : -1) * w->diag_r[i];
   }
 #if INDIRECT > 0
+  scs_float nm_ax_s_btau, nm_px_aty_ctau, nm_ws;
   /* compute warm start using the cone projection output */
+  nm_ax_s_btau = CG_NORM(w->r_normalized->ax_s_btau, m);
+  nm_px_aty_ctau = CG_NORM(w->r_normalized->px_aty_ctau, n);
   warm_start = w->lin_sys_warm_start;
-  memcpy(warm_start, w->u, (l - 1) * sizeof(scs_float));
   /* warm_start = u[:n] + tau * g[:n] */
-  SCS(add_scaled_array)(warm_start, w->g, l - 1, w->u[l - 1]);
+  memcpy(warm_start, w->u, n * sizeof(scs_float));
+  SCS(add_scaled_array)(warm_start, w->g, n, w->u[l - 1]);
   /* use normalized residuals to compute tolerance */
-  tol = MIN(CG_NORM(w->r_normalized->ax_s_btau, w->d->m),
-            CG_NORM(w->r_normalized->px_aty_ctau, w->d->n));
+  tol = MIN(nm_ax_s_btau, nm_px_aty_ctau);
   /* tol ~ O(1/k^(1+eps)) guarantees convergence */
   /* use warm-start to calculate tolerance rather than w->u_t, since warm_start
    * should be approximately equal to the true solution */
-  tol = CG_TOL_FACTOR * MIN(tol, CG_NORM(warm_start, w->d->n) /
-                                     POWF((scs_float)iter + 1, CG_RATE));
+  nm_ws = CG_NORM(warm_start, n) / POWF((scs_float)iter + 1, CG_RATE);
+  tol = CG_TOL_FACTOR * MIN(tol, nm_ws);
   tol = MAX(CG_BEST_TOL, tol);
 #endif
-  status = SCS(solve_lin_sys)(w->p, w->u_t, warm_start, tol);
+  status = scs_solve_lin_sys(w->p, w->u_t, warm_start, tol);
   if (iter < FEASIBLE_ITERS) {
     w->u_t[l - 1] = 1.;
   } else {
@@ -514,6 +524,7 @@ static void set_unfinished(const ScsWork *w, ScsSolution *sol, ScsInfo *info) {
 /* sets solutions, re-scales by inner prods if infeasible or unbounded */
 static void finalize(ScsWork *w, ScsSolution *sol, ScsInfo *info,
                      scs_int iter) {
+  scs_float nm_s, nm_y, sty;
   setx(w, sol);
   sety(w, sol);
   sets(w, sol);
@@ -521,6 +532,11 @@ static void finalize(ScsWork *w, ScsSolution *sol, ScsInfo *info,
     SCS(un_normalize_sol)(w->scal, sol);
   }
   populate_residual_struct(w, iter);
+
+  nm_s = SCS(norm_inf)(sol->s, w->d->m);
+  nm_y = SCS(norm_inf)(sol->y, w->d->m);
+  sty = SCS(dot)(sol->s, sol->y, w->d->m);
+
   info->setup_time = w->setup_time;
   info->iter = iter;
   info->res_infeas = w->r_orig->res_infeas;
@@ -530,9 +546,8 @@ static void finalize(ScsWork *w, ScsSolution *sol, ScsInfo *info,
   info->scale_updates = w->scale_updates;
   info->rejected_accel_steps = w->rejected_accel_steps;
   info->accepted_accel_steps = w->accepted_accel_steps;
-  info->comp_slack = ABS(SCS(dot)(sol->s, sol->y, w->d->m));
-  if (info->comp_slack > 1e-5 * MAX(SCS(norm_inf)(sol->s, w->d->m),
-                                    SCS(norm_inf)(sol->y, w->d->m))) {
+  info->comp_slack = ABS(sty);
+  if (info->comp_slack > 1e-5 * MAX(nm_s, nm_y)) {
     scs_printf("WARNING - large complementary slackness residual: %f\n",
                info->comp_slack);
   }
@@ -563,7 +578,9 @@ static void print_summary(ScsWork *w, scs_int i, SCS(timer) * solve_timer) {
   /* report mid point of primal and dual objective values */
   scs_printf("%*.2e ", (int)HSPACE, 0.5 * (r->pobj + r->dobj));
   scs_printf("%*.2e ", (int)HSPACE, w->stgs->scale);
-  scs_printf("%*.2e ", (int)HSPACE, SCS(tocq)(solve_timer) / 1e3);
+  /* Report TOTAL time, including setup */
+  scs_printf("%*.2e ", (int)HSPACE,
+             (SCS(tocq)(solve_timer) + w->setup_time) / 1e3);
   scs_printf("\n");
 
 #if VERBOSITY > 0
@@ -649,26 +666,29 @@ static void print_footer(ScsInfo *info) {
 }
 
 static scs_int has_converged(ScsWork *w, scs_int iter) {
+  scs_float abs_xt_p_x, abs_ctx, abs_bty;
+  scs_float nm_s, nm_px, nm_aty, nm_ax;
+  scs_float grl, prl, drl;
   scs_float eps_abs = w->stgs->eps_abs;
   scs_float eps_rel = w->stgs->eps_rel;
   scs_float eps_infeas = w->stgs->eps_infeas;
-  scs_float grl, prl, drl;
 
   ScsResiduals *r = w->r_orig;
-  scs_float *b = w->b_orig;
-  scs_float *c = w->c_orig;
-  scs_float *s = w->xys_orig->s;
 
   if (r->tau > 0.) {
+    abs_xt_p_x = ABS(r->xt_p_x);
+    abs_ctx = ABS(r->ctx);
+    abs_bty = ABS(r->bty);
+
+    nm_s = NORM(w->xys_orig->s, w->d->m);
+    nm_px = NORM(r->px, w->d->n);
+    nm_aty = NORM(r->aty, w->d->n);
+    nm_ax = NORM(r->ax, w->d->m);
     /* xt_p_x, ctx, bty already have tau divided out */
-    grl = MAX(MAX(ABS(r->xt_p_x), ABS(r->ctx)), ABS(r->bty));
+    grl = MAX(MAX(abs_xt_p_x, abs_ctx), abs_bty);
     /* s, ax, px, aty do *not* have tau divided out, so need to divide */
-    prl = MAX(MAX(NORM(b, w->d->m) * r->tau, NORM(s, w->d->m)),
-              NORM(r->ax, w->d->m)) /
-          r->tau;
-    drl = MAX(MAX(NORM(c, w->d->n) * r->tau, NORM(r->px, w->d->n)),
-              NORM(r->aty, w->d->n)) /
-          r->tau;
+    prl = MAX(MAX(w->nm_b_orig * r->tau, nm_s), nm_ax) / r->tau;
+    drl = MAX(MAX(w->nm_c_orig * r->tau, nm_px), nm_aty) / r->tau;
     if (isless(r->res_pri, eps_abs + eps_rel * prl) &&
         isless(r->res_dual, eps_abs + eps_rel * drl) &&
         isless(r->gap, eps_abs + eps_rel * grl)) {
@@ -685,7 +705,7 @@ static scs_int has_converged(ScsWork *w, scs_int iter) {
   return 0;
 }
 
-#if NOVALIDATE == 0
+#if NO_VALIDATE == 0
 static scs_int validate(const ScsData *d, const ScsCone *k,
                         const ScsSettings *stgs) {
   if (d->m <= 0 || d->n <= 0) {
@@ -762,12 +782,15 @@ scs_int scs_update(ScsWork *w, scs_float *b, scs_float *c) {
   } else {
     memcpy(w->d->b, w->b_orig, w->d->m * sizeof(scs_float));
   }
+  w->nm_b_orig = NORM(w->b_orig, w->d->m);
+
   if (c) {
     memcpy(w->c_orig, c, w->d->n * sizeof(scs_float));
     memcpy(w->d->c, c, w->d->n * sizeof(scs_float));
   } else {
     memcpy(w->d->c, w->c_orig, w->d->n * sizeof(scs_float));
   }
+  w->nm_c_orig = NORM(w->c_orig, w->d->n);
 
   /* normalize */
   if (w->scal) {
@@ -826,7 +849,7 @@ static ScsWork *init_work(const ScsData *d, const ScsCone *k,
   w->rsk = (scs_float *)scs_calloc(l, sizeof(scs_float));
   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->lin_sys_warm_start = (scs_float *)scs_calloc(w->d->n, 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));
@@ -864,7 +887,7 @@ static ScsWork *init_work(const ScsData *d, const ScsCone *k,
   /* set w->*_orig and performs normalization if appropriate */
   scs_update(w, w->d->b, w->d->c);
 
-  if (!(w->p = SCS(init_lin_sys_work)(w->d->A, w->d->P, w->diag_r))) {
+  if (!(w->p = scs_init_lin_sys_work(w->d->A, w->d->P, w->diag_r))) {
     scs_printf("ERROR: init_lin_sys_work failure\n");
     return SCS_NULL;
   }
@@ -891,7 +914,7 @@ static void update_work_cache(ScsWork *w) {
   /* g = (I + M)^{-1} h */
   memcpy(w->g, w->h, (w->d->n + w->d->m) * sizeof(scs_float));
   SCS(scale_array)(&(w->g[w->d->n]), -1., w->d->m);
-  SCS(solve_lin_sys)(w->p, w->g, SCS_NULL, CG_BEST_TOL);
+  scs_solve_lin_sys(w->p, w->g, SCS_NULL, CG_BEST_TOL);
   return;
 }
 
@@ -934,24 +957,27 @@ scs_int should_update_r(scs_float factor, scs_int iter) {
 
 static void update_scale(ScsWork *w, const ScsCone *k, scs_int iter) {
   scs_int i;
-  scs_float factor, new_scale;
+  scs_float factor, new_scale, relative_res_pri, relative_res_dual;
+  scs_float denom_pri, denom_dual;
 
   ScsResiduals *r = w->r_orig;
-  ScsSolution *xys = w->xys_orig;
-  scs_float *b = w->b_orig;
-  scs_float *c = w->c_orig;
+
+  scs_float nm_ax = SCALE_NORM(r->ax, w->d->m);
+  scs_float nm_s = SCALE_NORM(w->xys_orig->s, w->d->m);
+  scs_float nm_px_aty_ctau = SCALE_NORM(r->px_aty_ctau, w->d->n);
+  scs_float nm_px = SCALE_NORM(r->px, w->d->n);
+  scs_float nm_aty = SCALE_NORM(r->aty, w->d->n);
+  scs_float nm_ax_s_btau = SCALE_NORM(r->ax_s_btau, w->d->m);
 
   scs_int iters_since_last_update = iter - w->last_scale_update_iter;
   /* ||Ax + s - b * tau|| */
-  scs_float relative_res_pri = SAFEDIV_POS(
-      SCALE_NORM(r->ax_s_btau, w->d->m),
-      MAX(MAX(SCALE_NORM(r->ax, w->d->m), SCALE_NORM(xys->s, w->d->m)),
-          SCALE_NORM(b, w->d->m) * r->tau));
+  denom_pri = MAX(nm_ax, nm_s);
+  denom_pri = MAX(denom_pri, w->nm_b_orig * r->tau);
+  relative_res_pri = SAFEDIV_POS(nm_ax_s_btau, denom_pri);
   /* ||Px + A'y + c * tau|| */
-  scs_float relative_res_dual = SAFEDIV_POS(
-      SCALE_NORM(r->px_aty_ctau, w->d->n),
-      MAX(MAX(SCALE_NORM(r->px, w->d->n), SCALE_NORM(r->aty, w->d->n)),
-          SCALE_NORM(c, w->d->n) * r->tau));
+  denom_dual = MAX(nm_px, nm_aty);
+  denom_dual = MAX(denom_dual, w->nm_c_orig * r->tau);
+  relative_res_dual = SAFEDIV_POS(nm_px_aty_ctau, denom_dual);
 
   /* higher scale makes res_pri go down faster, so increase if res_pri larger */
   w->sum_log_scale_factor += log(relative_res_pri) - log(relative_res_dual);
@@ -981,7 +1007,7 @@ static void update_scale(ScsWork *w, const ScsCone *k, scs_int iter) {
     set_diag_r(w);
 
     /* update linear systems */
-    SCS(update_lin_sys_diag_r)(w->p, w->diag_r);
+    scs_update_lin_sys_diag_r(w->p, w->diag_r);
 
     /* update pre-solved quantities */
     update_work_cache(w);
@@ -1025,7 +1051,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)());
+  strcpy(info->lin_sys_solver, scs_get_lin_sys_method());
   info->status_val = SCS_UNFINISHED; /* not yet converged */
   update_work(w, sol);
 
@@ -1057,7 +1083,7 @@ scs_int scs_solve(ScsWork *w, ScsSolution *sol, ScsInfo *info,
 
     /******************* linear system solve ********************/
     SCS(tic)(&lin_sys_timer);
-    if (project_lin_sys(w, i) < 0) {
+    if (project_lin_sys(w, i) != 0) {
       return failure(w, w->d->m, w->d->n, sol, info, SCS_FAILED,
                      "error in project_lin_sys", "failure");
     }
@@ -1162,7 +1188,7 @@ void scs_finish(ScsWork *w) {
   if (w) {
     SCS(finish_cone)(w->cone_work);
     if (w->p) {
-      SCS(free_lin_sys_work)(w->p);
+      scs_free_lin_sys_work(w->p);
     }
     if (w->accel) {
       aa_finish(w->accel);
@@ -1179,7 +1205,7 @@ ScsWork *scs_init(const ScsData *d, const ScsCone *k, const ScsSettings *stgs) {
     scs_printf("ERROR: Missing ScsData or ScsCone input\n");
     return SCS_NULL;
   }
-#if NOVALIDATE == 0
+#if NO_VALIDATE == 0
   if (validate(d, k, stgs) < 0) {
     scs_printf("ERROR: Validation returned failure\n");
     return SCS_NULL;
@@ -1191,8 +1217,13 @@ ScsWork *scs_init(const ScsData *d, const ScsCone *k, const ScsSettings *stgs) {
 #endif
   SCS(tic)(&init_timer);
   if (stgs->write_data_filename) {
+    scs_printf("Writing raw problem data to %s\n", stgs->write_data_filename);
     SCS(write_data)(d, k, stgs);
   }
+  if (stgs->log_csv_filename) {
+    scs_printf("Logging run data to %s\n", stgs->log_csv_filename);
+    /* logging done every iteration */
+  }
   w = init_work(d, k, stgs);
   if (w) {
     w->setup_time = SCS(tocq)(&init_timer);

data/vendor/scs/src/util.c

@@ -5,7 +5,7 @@
 #include "scs_matrix.h"
 
 /* return milli-seconds */
-#if (defined NOTIMER)
+#if (defined NO_TIMER)
 
 void SCS(tic)(SCS(timer) * t) {
 }
@@ -84,13 +84,22 @@ void SCS(deep_copy_data)(ScsData *dest, const ScsData *src) {
 
 void 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) {
-    dest->write_data_filename = strdup(src->write_data_filename);
+    /* sizeof(char) = 1 */
+    tmp = (char *)scs_malloc(strlen(src->write_data_filename) + 1);
+    strcpy(tmp, src->write_data_filename);
+    dest->write_data_filename = tmp;
   } else {
     dest->write_data_filename = SCS_NULL;
   }
+  /* MATLAB does something weird with strdup, so use strcpy instead */
   if (src->log_csv_filename) {
-    dest->log_csv_filename = strdup(src->log_csv_filename);
+    /* sizeof(char) = 1 */
+    tmp = (char *)scs_malloc(strlen(src->log_csv_filename) + 1);
+    strcpy(tmp, src->log_csv_filename);
+    dest->log_csv_filename = tmp;
   } else {
     dest->log_csv_filename = SCS_NULL;
   }

data/vendor/scs/test/minunit.h

@@ -8,11 +8,13 @@
       return message;                                                          \
     }                                                                          \
   } while (0)
+
 #define mu_assert(message, test)                                               \
   do {                                                                         \
     if (!(test))                                                               \
       return message;                                                          \
   } while (0)
+
 #define mu_run_test(test) _mu_run_test(#test, test)
 
 #define _mu_run_test(name, test)                                               \
@@ -21,7 +23,6 @@
     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

@@ -190,6 +190,7 @@ const char *verify_solution_correct(ScsData *d, ScsCone *k, ScsSettings *stgs,
 
   /************** OPTIMALITY ****************/
 
+  /* TODO: the MAX expansion computes these norms many times */
   grl = MAX(MAX(ABS(xt_p_x), ABS(ctx)), ABS(bty));
   prl = MAX(MAX(NORM(b, m), NORM(s, m)), NORM(ax, m));
   drl = MAX(MAX(NORM(c, n), NORM(px, n)), NORM(aty, n));
@@ -215,7 +216,7 @@ const char *verify_solution_correct(ScsData *d, ScsCone *k, ScsSettings *stgs,
                    1e-9 * (1 + ABS(dobj)));
     /* slightly looser tol */
     mu_assert_less("Complementary slackness ERROR", ABS(sty),
-                   1e-8 * MAX(NORM(s, m), NORM(y, m)));
+                   5e-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);
 

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

@@ -68,7 +68,7 @@ static const char *hs21_tiny_qp(void) {
   scs_set_default_settings(stgs);
   stgs->eps_abs = 1e-6;
   stgs->eps_rel = 1e-6;
-  stgs->eps_infeas = 1e-9;
+  stgs->eps_infeas = 0.; /* disable due to gpu test finding cert */
 
   exitflag = scs(d, k, stgs, sol, &info);
 

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

@@ -16,7 +16,7 @@ static const char *hs21_tiny_qp_rw(void) {
   ScsInfo info = {0};
   scs_int exitflag;
   scs_float perr, derr;
-  scs_int success;
+  scs_int success, read_status;
   const char *fail;
 
   /* data */
@@ -70,7 +70,7 @@ static const char *hs21_tiny_qp_rw(void) {
   scs_set_default_settings(stgs);
   stgs->eps_abs = 1e-6;
   stgs->eps_rel = 1e-6;
-  stgs->eps_infeas = 1e-9;
+  stgs->eps_infeas = 0.; /* disable due to gpu test finding cert */
 
   stgs->write_data_filename = "hs21_tiny_qp";
   stgs->max_iters = 1;
@@ -84,7 +84,12 @@ static const char *hs21_tiny_qp_rw(void) {
   scs_free(stgs);
   scs_free(d);
 
-  SCS(read_data)("hs21_tiny_qp", &d, &k, &stgs);
+  read_status = SCS(read_data)("hs21_tiny_qp", &d, &k, &stgs);
+
+  if (read_status < 0) {
+    return "Data read failure, exit.\n";
+  }
+
   stgs->max_iters = 1000;
   /* solve with read data */
   exitflag = scs(d, k, stgs, sol, &info);

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

@@ -0,0 +1,8 @@
+#include "glbopts.h"
+#include "problems/test_prob_from_data_file.h"
+#include "scs.h"
+
+static const char *max_ent(void) {
+  scs_float OPT = -6.067087663361563; /* from ecos */
+  return _test_prob_from_data("test/problems/max_ent", OPT);
+}

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

@@ -1,49 +1,8 @@
 #include "glbopts.h"
-#include "minunit.h"
-#include "problem_utils.h"
-#include "rw.h"
+#include "problems/test_prob_from_data_file.h"
 #include "scs.h"
-#include "util.h"
 
 static const char *random_prob(void) {
-  scs_int read_status;
-  ScsData *d;
-  ScsCone *k;
-  ScsSettings *stgs;
-  ScsSolution *sol;
-  ScsInfo info = {0};
-  scs_int exitflag;
-  scs_float perr, derr;
-  scs_int success;
-  const char *fail;
-
   scs_float OPT = 5.751458006385587;
-
-  read_status = SCS(read_data)("test/problems/random_prob", &d, &k, &stgs);
-
-  if (read_status < 0) {
-    return "Data read failure, exit.\n";
-  }
-
-  stgs->eps_abs = 1e-6;
-  stgs->eps_rel = 1e-6;
-
-  sol = (ScsSolution *)scs_calloc(1, sizeof(ScsSolution));
-  exitflag = scs(d, k, stgs, sol, &info);
-
-  perr = SCS(dot)(d->c, sol->x, d->n) - OPT;
-  derr = -SCS(dot)(d->b, sol->y, d->m) - OPT;
-  scs_printf("primal obj error %4e\n", perr);
-  scs_printf("dual obj error %4e\n", derr);
-
-  success = ABS(perr) < 1e-4 && ABS(derr) < 1e-4 && exitflag == SCS_SOLVED;
-
-  mu_assert("random_prob: SCS failed to produce SCS_SOLVED", success);
-  fail = verify_solution_correct(d, k, stgs, &info, sol, exitflag);
-  SCS(free_data)(d);
-  SCS(free_cone)(k);
-  SCS(free_sol)(sol);
-  scs_free(stgs);
-
-  return fail;
+  return _test_prob_from_data("test/problems/random_prob", OPT);
 }

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

@@ -15,7 +15,7 @@ static const char *rob_gauss_cov_est(void) {
   ScsInfo info = {0};
   scs_int exitflag;
   scs_float perr, derr;
-  scs_int success;
+  scs_int success, read_status;
   const char *fail;
 
   /* data */
@@ -200,7 +200,12 @@ static const char *rob_gauss_cov_est(void) {
   scs_free(stgs);
   scs_free(d);
 
-  SCS(read_data)("rob_gauss_cov_est", &d, &k, &stgs);
+  read_status = SCS(read_data)("rob_gauss_cov_est", &d, &k, &stgs);
+
+  if (read_status < 0) {
+    return "Data read failure, exit.\n";
+  }
+
   stgs->max_iters = 1000;
   /* solve with read data */
   exitflag = scs(d, k, stgs, sol, &info);

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

@@ -0,0 +1,84 @@
+#include "glbopts.h"
+#include "linalg.h"
+#include "minunit.h"
+#include "scs.h"
+
+/* Forward declare exponential cone projection routine.
+ * Implemented in exp_cone.c.
+ */
+scs_float SCS(proj_pd_exp_cone)(scs_float *v0, scs_int primal);
+
+static scs_int _run_exp_cone_test(scs_float *v0, scs_float *vp_true,
+                                  scs_float *vd_true) {
+  scs_int success = 1;
+  scs_float vp[3], vd[3];
+  const scs_float TOL = 1e-6;
+
+  memcpy(vp, v0, 3 * sizeof(scs_float));
+  memcpy(vd, v0, 3 * sizeof(scs_float));
+
+  /* inefficient, but just for testing */
+  SCS(proj_pd_exp_cone)(vp, 1);
+  SCS(proj_pd_exp_cone)(vd, 0);
+
+  scs_printf("*******************************\n");
+  scs_printf("v0: (%f, %f, %f)\n", v0[0], v0[1], v0[2]);
+  scs_printf("vp: (%f, %f, %f)\n", vp[0], vp[1], vp[2]);
+  scs_printf("vp_true: (%f, %f, %f)\n", vp_true[0], vp_true[1], vp_true[2]);
+  scs_printf("vd: (%f, %f, %f)\n", vd[0], vd[1], vd[2]);
+  scs_printf("vd_true: (%f, %f, %f)\n", vd_true[0], vd_true[1], vd_true[2]);
+
+  success &= (SCS(norm_diff)(vp, vp_true, 3) <= TOL);
+  success &= (SCS(norm_diff)(vd, vd_true, 3) <= TOL);
+  /* Moreau decomposition holds only for polar */
+  /*
+  success &= (SCS(dot)(vp, vd, 3) <= TOL);
+  success &= (ABS(v0[0] - vp[0] + vd[0]) <= TOL);
+  success &= (ABS(v0[1] - vp[1] + vd[1]) <= TOL);
+  success &= (ABS(v0[2] - vp[2] + vd[2]) <= TOL);
+  */
+
+  if (!success) {
+    scs_printf("Failed.\n");
+  }
+
+  return success;
+}
+
+static const char *test_exp_cone(void) {
+  scs_int success = 1;
+  scs_int i;
+  /* test points */
+  scs_float v0[6][3] = {
+      {1, 2, 3},
+      {0.14814832, 1.04294573, 0.67905585},
+      {-0.78301134, 1.82790084, -1.05417044},
+      {1.3282585, -0.43277314, 1.7468072},
+      {0.67905585, 0.14814832, 1.04294573},
+      {0.50210027, 0.12314491, -1.77568921},
+  };
+  /* primal projections */
+  scs_float vp[6][3] = {
+      {0.8899428, 1.94041881, 3.06957226},
+      {-0.02001571, 0.8709169, 0.85112944},
+      {-1.17415616, 0.9567094, 0.280399},
+      {0.53160512, 0.2804836, 1.86652094},
+      {0.38322814, 0.27086569, 1.11482228},
+      {0., 0., 0.},
+  };
+  /* dual projections */
+  scs_float vd[6][3] = {
+      {-0., 2., 3.},
+      {-0., 1.04294573, 0.67905585},
+      {-0.68541419, 1.85424082, 0.01685653},
+      {-0.02277033, -0.12164823, 1.75085347},
+      {-0., 0.14814832, 1.04294573},
+      {-0., 0.12314491, -0.},
+  };
+
+  for (i = 0; i < 6; ++i) {
+    success &= _run_exp_cone_test(v0[i], vp[i], vd[i]);
+  }
+  mu_assert("test_exp_cone: Failure", success);
+  return 0;
+}

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

@@ -0,0 +1,57 @@
+#ifndef _SCS_FILE_TEST_CHASSIS
+#define _SCS_FILE_TEST_CHASSIS
+
+#include "glbopts.h"
+#include "minunit.h"
+#include "problem_utils.h"
+#include "rw.h"
+#include "scs.h"
+#include "util.h"
+
+static const char *_test_prob_from_data(const char *file, scs_float OPT) {
+  scs_int read_status;
+  ScsData *d;
+  ScsCone *k;
+  ScsSettings *stgs;
+  ScsSolution *sol;
+  ScsInfo info = {0};
+  scs_int exitflag;
+  scs_float perr, derr;
+  scs_int success;
+  const char *fail;
+
+  read_status = SCS(read_data)(file, &d, &k, &stgs);
+
+  if (read_status < 0) {
+    return "Data read failure, exit.\n";
+  }
+
+  stgs->eps_abs = 1e-6;
+  stgs->eps_rel = 1e-6;
+
+  sol = (ScsSolution *)scs_calloc(1, sizeof(ScsSolution));
+  exitflag = scs(d, k, stgs, sol, &info);
+
+  perr = SCS(dot)(d->c, sol->x, d->n) - OPT;
+  derr = -SCS(dot)(d->b, sol->y, d->m) - OPT;
+  scs_printf("primal obj error %4e\n", perr);
+  scs_printf("dual obj error %4e\n", derr);
+
+  success = ABS(perr) < 1e-4 && ABS(derr) < 1e-4 && exitflag == SCS_SOLVED;
+  if (!success) {
+    scs_printf("%s: FAILED\n", file);
+  }
+  mu_assert(file, success);
+  fail = verify_solution_correct(d, k, stgs, &info, sol, exitflag);
+  SCS(free_data)(d);
+  SCS(free_cone)(k);
+  SCS(free_sol)(sol);
+  scs_free(stgs);
+
+  if (fail) {
+    scs_printf("%s: FAILED\n", file);
+  }
+  return fail;
+}
+
+#endif