scs 0.4.0 → 0.4.2

data/vendor/scs/src/rw.c

@@ -1,5 +1,6 @@
 #include "rw.h"
 
+#include <errno.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -9,6 +10,25 @@
 #include "scs_matrix.h"
 #include "util.h"
 
+#if NO_READ_WRITE > 0 /* Disables all read / write functionality */
+
+void SCS(write_data)(const ScsData *d, const ScsCone *k,
+                     const ScsSettings *stgs) {
+  /* Do nothing */
+}
+scs_int SCS(read_data)(const char *filename, ScsData **d, ScsCone **k,
+                       ScsSettings **stgs) {
+  /* Failure */
+  return -1;
+}
+void SCS(log_data_to_csv)(const ScsCone *k, const ScsSettings *stgs,
+                          const ScsWork *w, scs_int iter,
+                          SCS(timer) * solve_timer) {
+  /* Do nothing */
+}
+
+#else
+
 /* writes/reads problem data to/from filename */
 /* This is a VERY naive implementation, doesn't care about portability etc */
 
@@ -28,30 +48,61 @@ static void write_scs_cone(const ScsCone *k, FILE *fout) {
   fwrite(k->p, sizeof(scs_float), k->psize, fout);
 }
 
-static ScsCone *read_scs_cone(FILE *fin) {
+/*
+ * Read integer data from file. If the integer width on file is
+ * different to scs_int then it will cast the ints after reading
+ * to be compatible with the SCS data types.
+ */
+static size_t read_int(scs_int *dest, size_t file_int_sz, size_t nitems,
+                       FILE *fin) {
+  if (file_int_sz == sizeof(scs_int)) {
+    return fread(dest, sizeof(scs_int), nitems, fin);
+  }
+  void *ptr = scs_calloc(nitems, file_int_sz);
+  size_t val = fread(ptr, file_int_sz, nitems, fin);
+  size_t i;
+  switch (file_int_sz) {
+  case 4:
+    for (i = 0; i < nitems; ++i) {
+      dest[i] = (scs_int)(((int *)ptr)[i]);
+    }
+    break;
+  case 8:
+    for (i = 0; i < nitems; ++i) {
+      dest[i] = (scs_int)(((long long *)ptr)[i]);
+    }
+    break;
+  }
+  if (ptr) {
+    scs_free(ptr);
+  }
+  return val;
+}
+
+static ScsCone *read_scs_cone(FILE *fin, size_t file_int_sz) {
   ScsCone *k = (ScsCone *)scs_calloc(1, sizeof(ScsCone));
-  fread(&(k->z), sizeof(scs_int), 1, fin);
-  fread(&(k->l), sizeof(scs_int), 1, fin);
-  fread(&(k->bsize), sizeof(scs_int), 1, fin);
+  read_int(&(k->z), file_int_sz, 1, fin);
+  read_int(&(k->l), file_int_sz, 1, fin);
+  read_int(&(k->bsize), file_int_sz, 1, fin);
   if (k->bsize > 1) {
     k->bl = (scs_float *)scs_calloc(MAX(k->bsize - 1, 0), sizeof(scs_float));
     k->bu = (scs_float *)scs_calloc(MAX(k->bsize - 1, 0), sizeof(scs_float));
     fread(k->bl, sizeof(scs_float), MAX(k->bsize - 1, 0), fin);
     fread(k->bu, sizeof(scs_float), MAX(k->bsize - 1, 0), fin);
   }
-  fread(&(k->qsize), sizeof(scs_int), 1, fin);
+  read_int(&(k->qsize), file_int_sz, 1, fin);
   if (k->qsize) {
     k->q = (scs_int *)scs_calloc(k->qsize, sizeof(scs_int));
-    fread(k->q, sizeof(scs_int), k->qsize, fin);
+    read_int(k->q, file_int_sz, k->qsize, fin);
   }
-  fread(&(k->ssize), sizeof(scs_int), 1, fin);
+  read_int(&(k->ssize), file_int_sz, 1, fin);
   if (k->ssize) {
     k->s = (scs_int *)scs_calloc(k->ssize, sizeof(scs_int));
-    fread(k->s, sizeof(scs_int), k->ssize, fin);
+    read_int(k->s, file_int_sz, k->ssize, fin);
   }
-  fread(&(k->ep), sizeof(scs_int), 1, fin);
-  fread(&(k->ed), sizeof(scs_int), 1, fin);
-  fread(&(k->psize), sizeof(scs_int), 1, fin);
+  read_int(&(k->ep), file_int_sz, 1, fin);
+  read_int(&(k->ed), file_int_sz, 1, fin);
+  read_int(&(k->psize), file_int_sz, 1, fin);
   if (k->psize) {
     k->p = (scs_float *)scs_calloc(k->psize, sizeof(scs_float));
     fread(k->p, sizeof(scs_float), k->psize, fin);
@@ -79,21 +130,21 @@ static void write_scs_stgs(const ScsSettings *s, FILE *fout) {
   /* Do not write the log_csv_filename */
 }
 
-static ScsSettings *read_scs_stgs(FILE *fin) {
+static ScsSettings *read_scs_stgs(FILE *fin, size_t file_int_sz) {
   ScsSettings *s = (ScsSettings *)scs_calloc(1, sizeof(ScsSettings));
-  fread(&(s->normalize), sizeof(scs_int), 1, fin);
+  read_int(&(s->normalize), file_int_sz, 1, fin);
   fread(&(s->scale), sizeof(scs_float), 1, fin);
   fread(&(s->rho_x), sizeof(scs_float), 1, fin);
-  fread(&(s->max_iters), sizeof(scs_int), 1, fin);
+  read_int(&(s->max_iters), file_int_sz, 1, fin);
   fread(&(s->eps_abs), sizeof(scs_float), 1, fin);
   fread(&(s->eps_rel), sizeof(scs_float), 1, fin);
   fread(&(s->eps_infeas), sizeof(scs_float), 1, fin);
   fread(&(s->alpha), sizeof(scs_float), 1, fin);
-  fread(&(s->verbose), sizeof(scs_int), 1, fin);
-  fread(&(s->warm_start), sizeof(scs_int), 1, fin);
-  fread(&(s->acceleration_lookback), sizeof(scs_int), 1, fin);
-  fread(&(s->acceleration_interval), sizeof(scs_int), 1, fin);
-  fread(&(s->adaptive_scale), sizeof(scs_int), 1, fin);
+  read_int(&(s->verbose), file_int_sz, 1, fin);
+  read_int(&(s->warm_start), file_int_sz, 1, fin);
+  read_int(&(s->acceleration_lookback), file_int_sz, 1, fin);
+  read_int(&(s->acceleration_interval), file_int_sz, 1, fin);
+  read_int(&(s->adaptive_scale), file_int_sz, 1, fin);
   return s;
 }
 
@@ -106,18 +157,18 @@ static void write_amatrix(const ScsMatrix *A, FILE *fout) {
   fwrite(A->i, sizeof(scs_int), Anz, fout);
 }
 
-static ScsMatrix *read_amatrix(FILE *fin) {
+static ScsMatrix *read_amatrix(FILE *fin, size_t file_int_sz) {
   scs_int Anz;
   ScsMatrix *A = (ScsMatrix *)scs_calloc(1, sizeof(ScsMatrix));
-  fread(&(A->m), sizeof(scs_int), 1, fin);
-  fread(&(A->n), sizeof(scs_int), 1, fin);
+  read_int(&(A->m), file_int_sz, 1, fin);
+  read_int(&(A->n), file_int_sz, 1, fin);
   A->p = (scs_int *)scs_calloc(A->n + 1, sizeof(scs_int));
-  fread(A->p, sizeof(scs_int), A->n + 1, fin);
+  read_int(A->p, file_int_sz, A->n + 1, fin);
   Anz = A->p[A->n];
   A->x = (scs_float *)scs_calloc(Anz, sizeof(scs_float));
   A->i = (scs_int *)scs_calloc(Anz, sizeof(scs_int));
   fread(A->x, sizeof(scs_float), Anz, fin);
-  fread(A->i, sizeof(scs_int), Anz, fin);
+  read_int(A->i, file_int_sz, Anz, fin);
   return A;
 }
 
@@ -135,19 +186,20 @@ static void write_scs_data(const ScsData *d, FILE *fout) {
   }
 }
 
-static ScsData *read_scs_data(FILE *fin) {
+static ScsData *read_scs_data(FILE *fin, size_t file_int_sz) {
   scs_int has_p = 0;
   ScsData *d = (ScsData *)scs_calloc(1, sizeof(ScsData));
-  fread(&(d->m), sizeof(scs_int), 1, fin);
-  fread(&(d->n), sizeof(scs_int), 1, fin);
+
+  read_int(&(d->m), file_int_sz, 1, fin);
+  read_int(&(d->n), file_int_sz, 1, fin);
   d->b = (scs_float *)scs_calloc(d->m, sizeof(scs_float));
   d->c = (scs_float *)scs_calloc(d->n, sizeof(scs_float));
   fread(d->b, sizeof(scs_float), d->m, fin);
   fread(d->c, sizeof(scs_float), d->n, fin);
-  d->A = read_amatrix(fin);
+  d->A = read_amatrix(fin, file_int_sz);
   /* If has_p bit is not set or this hits end of file then has_p = 0 */
-  has_p &= fread(&has_p, sizeof(scs_int), 1, fin);
-  d->P = has_p ? read_amatrix(fin) : SCS_NULL;
+  has_p &= read_int(&has_p, file_int_sz, 1, fin);
+  d->P = has_p ? read_amatrix(fin, file_int_sz) : SCS_NULL;
   return d;
 }
 
@@ -158,7 +210,6 @@ void SCS(write_data)(const ScsData *d, const ScsCone *k,
   uint32_t scs_float_sz = (uint32_t)sizeof(scs_float);
   const char *scs_version = SCS_VERSION;
   uint32_t scs_version_sz = (uint32_t)strlen(scs_version);
-  scs_printf("writing data to %s\n", stgs->write_data_filename);
   fwrite(&(scs_int_sz), sizeof(uint32_t), 1, fout);
   fwrite(&(scs_float_sz), sizeof(uint32_t), 1, fout);
   fwrite(&(scs_version_sz), sizeof(uint32_t), 1, fout);
@@ -175,9 +226,11 @@ scs_int SCS(read_data)(const char *filename, ScsData **d, ScsCone **k,
   uint32_t file_float_sz;
   uint32_t file_version_sz;
   char file_version[16];
+  errno = 0;
   FILE *fin = fopen(filename, "rb");
   if (!fin) {
     scs_printf("Error reading file %s\n", filename);
+    scs_printf("errno:%i:%s\n", errno, strerror(errno));
     return -1;
   }
   scs_printf("Reading data from %s\n", filename);
@@ -185,11 +238,10 @@ scs_int SCS(read_data)(const char *filename, ScsData **d, ScsCone **k,
   fread(&(file_float_sz), sizeof(uint32_t), 1, fin);
   if (file_int_sz != (uint32_t)sizeof(scs_int)) {
     scs_printf(
-        "Error, sizeof(file int) is %lu, but scs expects sizeof(int) %lu, "
-        "scs should be recompiled with correct flags.\n",
+        "Warning, sizeof(file int) is %lu, but scs expects sizeof(int) %lu. "
+        "SCS will attempt to cast the data, which may be slow. "
+        "This message can be avoided by recompiling with the correct flags.\n",
         (unsigned long)file_int_sz, (unsigned long)sizeof(scs_int));
-    fclose(fin);
-    return -1;
   }
   if (file_float_sz != (uint32_t)sizeof(scs_float)) {
     scs_printf(
@@ -209,9 +261,10 @@ scs_int SCS(read_data)(const char *filename, ScsData **d, ScsCone **k,
                "************************************************************\n",
                file_version, SCS_VERSION);
   }
-  *k = read_scs_cone(fin);
-  *d = read_scs_data(fin);
-  *stgs = read_scs_stgs(fin);
+  *k = read_scs_cone(fin, file_int_sz);
+  *d = read_scs_data(fin, file_int_sz);
+  *stgs = read_scs_stgs(fin, file_int_sz);
+  scs_printf("Finished reading data.\n");
   fclose(fin);
   return 0;
 }
@@ -275,8 +328,15 @@ void SCS(log_data_to_csv)(const ScsCone *k, const ScsSettings *stgs,
                   "tau_normalized,"
                   "kap_normalized,"
                   "ax_nrm_inf,"
+                  "ax_s_nrm_inf"
                   "px_nrm_inf,"
                   "aty_nrm_inf,"
+                  "xt_p_x,"
+                  "xt_p_x_tau,"
+                  "ctx,"
+                  "ctx_tau,"
+                  "bty,"
+                  "bty_tau,"
                   "b_nrm_inf,"
                   "c_nrm_inf,"
                   "scale,"
@@ -332,8 +392,15 @@ void SCS(log_data_to_csv)(const ScsCone *k, const ScsSettings *stgs,
   fprintf(fout, "%.16e,", r_n->tau);
   fprintf(fout, "%.16e,", r_n->kap);
   fprintf(fout, "%.16e,", SCS(norm_inf)(r->ax, w->d->m));
+  fprintf(fout, "%.16e,", SCS(norm_inf)(r->ax_s, w->d->m));
   fprintf(fout, "%.16e,", SCS(norm_inf)(r->px, w->d->n));
   fprintf(fout, "%.16e,", SCS(norm_inf)(r->aty, w->d->n));
+  fprintf(fout, "%.16e,", r->xt_p_x);
+  fprintf(fout, "%.16e,", r->xt_p_x_tau);
+  fprintf(fout, "%.16e,", r->ctx);
+  fprintf(fout, "%.16e,", r->ctx_tau);
+  fprintf(fout, "%.16e,", r->bty);
+  fprintf(fout, "%.16e,", r->bty_tau);
   fprintf(fout, "%.16e,", SCS(norm_inf)(w->b_orig, w->d->m));
   fprintf(fout, "%.16e,", SCS(norm_inf)(w->c_orig, w->d->n));
   fprintf(fout, "%.16e,", w->stgs->scale);
@@ -348,3 +415,5 @@ void SCS(log_data_to_csv)(const ScsCone *k, const ScsSettings *stgs,
   fprintf(fout, "\n");
   fclose(fout);
 }
+
+#endif

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;
@@ -112,6 +112,9 @@ static void print_init_header(const ScsData *d, const ScsCone *k,
   if (stgs->time_limit_secs) {
     scs_printf("\t  time_limit_secs: %.2e\n", stgs->time_limit_secs);
   }
+#ifdef _OPENMP
+  scs_printf("\t  compiled with openmp parallelization enabled\n");
+#endif
   if (lin_sys_method) {
     scs_printf("lin-sys:  %s\n\t  nnz(A): %li, nnz(P): %li\n", lin_sys_method,
                (long)d->A->p[d->A->n], d->P ? (long)d->P->p[d->P->n] : 0l);
@@ -195,17 +198,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);
+  if (r->ctx_tau < -INFEAS_NEGATIVITY_TOL) {
+    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);
+  if (r->bty_tau < -INFEAS_NEGATIVITY_TOL) {
+    nm_aty = NORM(r->aty, n);
+    r->res_infeas = SAFEDIV_POS(nm_aty, -r->bty_tau);
   }
 }
 
@@ -347,14 +357,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 +375,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 +527,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 +535,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 +549,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,26 +581,28 @@ 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
-  scs_printf("Norm u = %4f, ", SCS(norm_2)(w->u, w->d->n + w->d->m + 1));
-  scs_printf("Norm u_t = %4f, ", SCS(norm_2)(w->u_t, w->d->n + w->d->m + 1));
-  scs_printf("Norm v = %4f, ", SCS(norm_2)(w->v, w->d->n + w->d->m + 1));
-  scs_printf("Norm rsk = %4f, ", SCS(norm_2)(w->rsk, w->d->n + w->d->m + 1));
-  scs_printf("Norm x = %4f, ", SCS(norm_2)(w->xys_orig->x, w->d->n));
-  scs_printf("Norm y = %4f, ", SCS(norm_2)(w->xys_orig->y, w->d->m));
-  scs_printf("Norm s = %4f, ", SCS(norm_2)(w->xys_orig->s, w->d->m));
-  scs_printf("Norm |Ax + s| = %1.2e, ", SCS(norm_2)(r->ax_s, w->d->m));
-  scs_printf("tau = %4f, ", w->u[w->d->n + w->d->m]);
-  scs_printf("kappa = %4f, ", w->rsk[w->d->n + w->d->m]);
-  scs_printf("|u - u_t| = %1.2e, ",
+  scs_printf("Norm u = %1.6e, ", SCS(norm_2)(w->u, w->d->n + w->d->m + 1));
+  scs_printf("Norm u_t = %1.6e, ", SCS(norm_2)(w->u_t, w->d->n + w->d->m + 1));
+  scs_printf("Norm v = %1.6e, ", SCS(norm_2)(w->v, w->d->n + w->d->m + 1));
+  scs_printf("Norm rsk = %1.6e, ", SCS(norm_2)(w->rsk, w->d->n + w->d->m + 1));
+  scs_printf("Norm x = %1.6e, ", SCS(norm_2)(w->xys_orig->x, w->d->n));
+  scs_printf("Norm y = %1.6e, ", SCS(norm_2)(w->xys_orig->y, w->d->m));
+  scs_printf("Norm s = %1.6e, ", SCS(norm_2)(w->xys_orig->s, w->d->m));
+  scs_printf("Norm |Ax + s| = %1.6e, ", SCS(norm_2)(r->ax_s, w->d->m));
+  scs_printf("tau = %1.6e, ", w->u[w->d->n + w->d->m]);
+  scs_printf("kappa = %1.6e, ", w->rsk[w->d->n + w->d->m]);
+  scs_printf("|u - u_t| = %1.6e, ",
              SCS(norm_diff)(w->u, w->u_t, w->d->n + w->d->m + 1));
-  scs_printf("res_infeas = %1.2e, ", r->res_infeas);
-  scs_printf("res_unbdd_a = %1.2e, ", r->res_unbdd_a);
-  scs_printf("res_unbdd_p = %1.2e, ", r->res_unbdd_p);
-  scs_printf("ctx_tau = %1.2e, ", r->ctx_tau);
+  scs_printf("res_infeas = %1.6e, ", r->res_infeas);
+  scs_printf("res_unbdd_a = %1.6e, ", r->res_unbdd_a);
+  scs_printf("res_unbdd_p = %1.6e, ", r->res_unbdd_p);
+  scs_printf("ctx_tau = %1.6e, ", r->ctx_tau);
   scs_printf("bty_tau = %1.2e\n", r->bty_tau);
 #endif
 
@@ -649,26 +669,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 +708,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 +785,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 +852,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 +890,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 +917,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 +960,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 +1010,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 +1054,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 +1086,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 +1191,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 +1208,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 +1220,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;
   }