scs 0.2.3 → 0.3.0

data/vendor/scs/src/ctrlc.c

@@ -22,9 +22,13 @@ void scs_start_interrupt_listener(void) {
   istate = (int)utSetInterruptEnabled(true);
 }
 
-void scs_end_interrupt_listener(void) { utSetInterruptEnabled((bool)istate); }
+void scs_end_interrupt_listener(void) {
+  utSetInterruptEnabled((bool)istate);
+}
 
-int scs_is_interrupted(void) { return (int)utIsInterruptPending(); }
+int scs_is_interrupted(void) {
+  return (int)utIsInterruptPending();
+}
 
 #elif (defined _WIN32 || _WIN64 || defined _WINDLL)
 #include <windows.h>
@@ -47,14 +51,18 @@ void scs_end_interrupt_listener(void) {
   SetConsoleCtrlHandler(scs_handle_ctrlc, FALSE);
 }
 
-int scs_is_interrupted(void) { return int_detected; }
+int scs_is_interrupted(void) {
+  return int_detected;
+}
 
 #else /* Unix */
 
 #include <signal.h>
 static int int_detected;
 struct sigaction oact;
-static void scs_handle_ctrlc(int dummy) { int_detected = dummy ? dummy : -1; }
+static void scs_handle_ctrlc(int dummy) {
+  int_detected = dummy ? dummy : -1;
+}
 
 void scs_start_interrupt_listener(void) {
   struct sigaction act;
@@ -70,7 +78,9 @@ void scs_end_interrupt_listener(void) {
   sigaction(SIGINT, &oact, &act);
 }
 
-int scs_is_interrupted(void) { return int_detected; }
+int scs_is_interrupted(void) {
+  return int_detected;
+}
 
 #endif /* END IF MATLAB_MEX_FILE / WIN32 */
 

data/vendor/scs/src/linalg.c

@@ -1,17 +1,40 @@
 #include "linalg.h"
+#include "scs_blas.h"
 #include <math.h>
 
-/* x = b*a */
-void SCS(set_as_scaled_array)(scs_float *x, const scs_float *a,
-                              const scs_float b, scs_int len) {
+/* these routines do not have BLAS implementations (that I can find at least) */
+
+scs_float SCS(norm_diff)(const scs_float *a, const scs_float *b, scs_int len) {
+  scs_float nm_diff = 0.0, tmp;
+  scs_int i;
+  for (i = 0; i < len; ++i) {
+    tmp = (a[i] - b[i]);
+    nm_diff += tmp * tmp;
+  }
+  return SQRTF(nm_diff);
+}
+
+scs_float SCS(norm_inf_diff)(const scs_float *a, const scs_float *b,
+                             scs_int len) {
+  scs_float tmp, max = 0.0;
   scs_int i;
-  for (i = 0; i < len; ++i) x[i] = b * a[i];
+  for (i = 0; i < len; ++i) {
+    tmp = ABS(a[i] - b[i]);
+    if (tmp > max) {
+      max = tmp;
+    }
+  }
+  return max;
 }
 
+#ifndef USE_LAPACK
+/* Self-rolled basic linear algebra routines */
+
 /* a *= b */
 void SCS(scale_array)(scs_float *a, const scs_float b, scs_int len) {
   scs_int i;
-  for (i = 0; i < len; ++i) a[i] *= b;
+  for (i = 0; i < len; ++i)
+    a[i] *= b;
 }
 
 /* x'*y */
@@ -35,14 +58,14 @@ scs_float SCS(norm_sq)(const scs_float *v, scs_int len) {
 }
 
 /* ||v||_2 */
-scs_float SCS(norm)(const scs_float *v, scs_int len) {
+scs_float SCS(norm_2)(const scs_float *v, scs_int len) {
   return SQRTF(SCS(norm_sq)(v, len));
 }
 
-scs_float SCS(norm_inf)(const scs_float *a, scs_int l) {
+scs_float SCS(norm_inf)(const scs_float *a, scs_int len) {
   scs_float tmp, max = 0.0;
   scs_int i;
-  for (i = 0; i < l; ++i) {
+  for (i = 0; i < len; ++i) {
     tmp = ABS(a[i]);
     if (tmp > max) {
       max = tmp;
@@ -51,7 +74,7 @@ scs_float SCS(norm_inf)(const scs_float *a, scs_int l) {
   return max;
 }
 
-/* saxpy a += sc*b */
+/* axpy a += sc*b */
 void SCS(add_scaled_array)(scs_float *a, const scs_float *b, scs_int n,
                            const scs_float sc) {
   scs_int i;
@@ -60,25 +83,58 @@ void SCS(add_scaled_array)(scs_float *a, const scs_float *b, scs_int n,
   }
 }
 
-scs_float SCS(norm_diff)(const scs_float *a, const scs_float *b, scs_int l) {
-  scs_float nm_diff = 0.0, tmp;
-  scs_int i;
-  for (i = 0; i < l; ++i) {
-    tmp = (a[i] - b[i]);
-    nm_diff += tmp * tmp;
-  }
-  return SQRTF(nm_diff);
+#else
+/* If we have BLAS / LAPACK we may as well use them */
+
+scs_float BLAS(nrm2)(blas_int *n, const scs_float *x, blas_int *incx);
+scs_float BLAS(dot)(const blas_int *n, const scs_float *x, const blas_int *incx,
+                    const scs_float *y, const blas_int *incy);
+scs_float BLAS(lange)(const char *norm, const blas_int *m, const blas_int *n,
+                      const scs_float *a, blas_int *lda, scs_float *work);
+void BLAS(axpy)(blas_int *n, const scs_float *a, const scs_float *x,
+                blas_int *incx, scs_float *y, blas_int *incy);
+void BLAS(scal)(const blas_int *n, const scs_float *sa, scs_float *sx,
+                const blas_int *incx);
+
+/* a *= b */
+void SCS(scale_array)(scs_float *a, const scs_float b, scs_int len) {
+  blas_int bone = 1;
+  blas_int blen = (blas_int)len;
+  BLAS(scal)(&blen, &b, a, &bone);
 }
 
-scs_float SCS(norm_inf_diff)(const scs_float *a, const scs_float *b,
-                             scs_int l) {
-  scs_float tmp, max = 0.0;
-  scs_int i;
-  for (i = 0; i < l; ++i) {
-    tmp = ABS(a[i] - b[i]);
-    if (tmp > max) {
-      max = tmp;
-    }
-  }
-  return max;
+/* x'*y */
+scs_float SCS(dot)(const scs_float *x, const scs_float *y, scs_int len) {
+  blas_int bone = 1;
+  blas_int blen = (blas_int)len;
+  return BLAS(dot)(&blen, x, &bone, y, &bone);
 }
+
+/* ||v||_2^2 */
+scs_float SCS(norm_sq)(const scs_float *v, scs_int len) {
+  scs_float nrm = SCS(norm_2)(v, len);
+  return nrm * nrm;
+}
+
+/* ||v||_2 */
+scs_float SCS(norm_2)(const scs_float *v, scs_int len) {
+  blas_int bone = 1;
+  blas_int blen = (blas_int)len;
+  return BLAS(nrm2)(&blen, v, &bone);
+}
+
+scs_float SCS(norm_inf)(const scs_float *a, scs_int len) {
+  blas_int bone = 1;
+  blas_int blen = (blas_int)len;
+  return BLAS(lange)("Max", &blen, &bone, a, &bone, SCS_NULL);
+}
+
+/* axpy a += sc*b */
+void SCS(add_scaled_array)(scs_float *a, const scs_float *b, scs_int len,
+                           const scs_float sc) {
+  blas_int bone = 1;
+  blas_int blen = (blas_int)len;
+  BLAS(axpy)(&blen, &sc, b, &bone, a, &bone);
+}
+
+#endif

data/vendor/scs/src/normalize.c

@@ -1,93 +1,51 @@
 #include "normalize.h"
+
 #include "linalg.h"
 #include "scs.h"
 
-#define MIN_SCALE (1e-6)
-
-void SCS(normalize_b_c)(ScsWork *w) {
+/* needed for normalizing the warm-start */
+void SCS(normalize_sol)(ScsWork *w, ScsSolution *sol) {
   scs_int i;
-  scs_float nm, *D = w->scal->D, *E = w->scal->E, *b = w->b, *c = w->c;
-  /* scale b */
-  for (i = 0; i < w->m; ++i) {
-    b[i] /= D[i];
-  }
-  nm = SCS(norm)(b, w->m);
-  w->sc_b = w->scal->mean_norm_col_a / MAX(nm, MIN_SCALE);
-  /* scale c */
-  for (i = 0; i < w->n; ++i) {
-    c[i] /= E[i];
-  }
-  nm = SCS(norm)(c, w->n);
-  w->sc_c = w->scal->mean_norm_row_a / MAX(nm, MIN_SCALE);
-  SCS(scale_array)(b, w->sc_b * w->stgs->scale, w->m);
-  SCS(scale_array)(c, w->sc_c * w->stgs->scale, w->n);
-}
-
-void SCS(calc_scaled_resids)(ScsWork *w, ScsResiduals *r) {
   scs_float *D = w->scal->D;
   scs_float *E = w->scal->E;
-  scs_float *u = w->u;
-  scs_float *u_t = w->u_t;
-  scs_float *u_prev = w->u_prev;
-  scs_float tmp;
-  scs_int i, n = w->n, m = w->m;
-
-  r->res_pri = 0;
-  for (i = 0; i < n; ++i) {
-    tmp = (u[i] - u_t[i]) / (E[i] * w->sc_b);
-    r->res_pri += tmp * tmp;
-  }
-  for (i = 0; i < m; ++i) {
-    tmp = (u[i + n] - u_t[i + n]) / (D[i] * w->sc_c);
-    r->res_pri += tmp * tmp;
+  for (i = 0; i < w->n; ++i) {
+    sol->x[i] /= (E[i] / w->scal->dual_scale);
   }
-  tmp = u[n + m] - u_t[n + m];
-  r->res_pri += tmp * tmp;
-  r->res_pri = sqrt(r->res_pri);
-
-  r->res_dual = 0;
-  for (i = 0; i < n; ++i) {
-    tmp = (u[i] - u_prev[i]) * E[i] / w->sc_b;
-    r->res_dual += tmp * tmp;
+  for (i = 0; i < w->m; ++i) {
+    sol->y[i] /= (D[i] / w->scal->primal_scale);
   }
-  for (i = 0; i < m; ++i) {
-    tmp = (u[i + n] - u_prev[i + n]) * D[i] / w->sc_c;
-    r->res_dual += tmp * tmp;
+  for (i = 0; i < w->m; ++i) {
+    sol->s[i] *= (D[i] * w->scal->dual_scale);
   }
-  tmp = u[n + m] - u_t[n + m];
-  r->res_dual += tmp * tmp;
-  r->res_dual = sqrt(r->res_dual);
 }
 
-void SCS(normalize_warm_start)(ScsWork *w) {
+void SCS(un_normalize_sol)(ScsWork *w, ScsSolution *sol) {
   scs_int i;
   scs_float *D = w->scal->D;
   scs_float *E = w->scal->E;
-  scs_float *x = w->u;
-  scs_float *y = &(w->u[w->n]);
-  scs_float *s = &(w->v[w->n]);
   for (i = 0; i < w->n; ++i) {
-    x[i] *= (E[i] * w->sc_b);
+    sol->x[i] *= (E[i] / w->scal->dual_scale);
   }
   for (i = 0; i < w->m; ++i) {
-    y[i] *= (D[i] * w->sc_c);
+    sol->y[i] *= (D[i] / w->scal->primal_scale);
   }
   for (i = 0; i < w->m; ++i) {
-    s[i] /= (D[i] / (w->sc_b * w->stgs->scale));
+    sol->s[i] /= (D[i] * w->scal->dual_scale);
   }
 }
 
-void SCS(un_normalize_sol)(ScsWork *w, ScsSolution *sol) {
+void SCS(un_normalize_primal)(ScsWork *w, scs_float *r) {
   scs_int i;
   scs_float *D = w->scal->D;
-  scs_float *E = w->scal->E;
-  for (i = 0; i < w->n; ++i) {
-    sol->x[i] /= (E[i] * w->sc_b);
-  }
   for (i = 0; i < w->m; ++i) {
-    sol->y[i] /= (D[i] * w->sc_c);
+    r[i] /= (D[i] * w->scal->dual_scale);
   }
-  for (i = 0; i < w->m; ++i) {
-    sol->s[i] *= D[i] / (w->sc_b * w->stgs->scale);
+}
+
+void SCS(un_normalize_dual)(ScsWork *w, scs_float *r) {
+  scs_int i;
+  scs_float *E = w->scal->E;
+  for (i = 0; i < w->n; ++i) {
+    r[i] /= (E[i] * w->scal->primal_scale);
   }
 }

data/vendor/scs/src/rw.c

@@ -4,16 +4,20 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-#include "amatrix.h"
+#include "linalg.h"
 #include "scs.h"
+#include "scs_matrix.h"
 #include "util.h"
 
 /* writes/reads problem data to/from filename */
 /* This is a VERY naive implementation, doesn't care about portability etc */
 
 static void write_scs_cone(const ScsCone *k, FILE *fout) {
-  fwrite(&(k->f), sizeof(scs_int), 1, fout);
+  fwrite(&(k->z), sizeof(scs_int), 1, fout);
   fwrite(&(k->l), sizeof(scs_int), 1, fout);
+  fwrite(&(k->bsize), sizeof(scs_int), 1, fout);
+  fwrite(k->bl, sizeof(scs_float), MAX(k->bsize - 1, 0), fout);
+  fwrite(k->bu, sizeof(scs_float), MAX(k->bsize - 1, 0), fout);
   fwrite(&(k->qsize), sizeof(scs_int), 1, fout);
   fwrite(k->q, sizeof(scs_int), k->qsize, fout);
   fwrite(&(k->ssize), sizeof(scs_int), 1, fout);
@@ -26,8 +30,13 @@ static void write_scs_cone(const ScsCone *k, FILE *fout) {
 
 static ScsCone *read_scs_cone(FILE *fin) {
   ScsCone *k = (ScsCone *)scs_calloc(1, sizeof(ScsCone));
-  fread(&(k->f), sizeof(scs_int), 1, fin);
+  fread(&(k->z), sizeof(scs_int), 1, fin);
   fread(&(k->l), sizeof(scs_int), 1, fin);
+  fread(&(k->bsize), sizeof(scs_int), 1, fin);
+  k->bl = scs_calloc(MAX(k->bsize - 1, 0), sizeof(scs_float));
+  k->bu = 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);
   k->q = scs_calloc(k->qsize, sizeof(scs_int));
   fread(k->q, sizeof(scs_int), k->qsize, fin);
@@ -49,13 +58,17 @@ static void write_scs_stgs(const ScsSettings *s, FILE *fout) {
   fwrite(&(s->scale), sizeof(scs_float), 1, fout);
   fwrite(&(s->rho_x), sizeof(scs_float), 1, fout);
   fwrite(&(s->max_iters), sizeof(scs_int), 1, fout);
-  fwrite(&(s->eps), sizeof(scs_float), 1, fout);
+  fwrite(&(s->eps_abs), sizeof(scs_float), 1, fout);
+  fwrite(&(s->eps_rel), sizeof(scs_float), 1, fout);
+  fwrite(&(s->eps_infeas), sizeof(scs_float), 1, fout);
   fwrite(&(s->alpha), sizeof(scs_float), 1, fout);
-  fwrite(&(s->cg_rate), sizeof(scs_float), 1, fout);
   fwrite(&(s->verbose), sizeof(scs_int), 1, fout);
   fwrite(&warm_start, sizeof(scs_int), 1, fout);
   fwrite(&(s->acceleration_lookback), sizeof(scs_int), 1, fout);
+  fwrite(&(s->acceleration_interval), sizeof(scs_int), 1, fout);
+  fwrite(&(s->adaptive_scale), sizeof(scs_int), 1, fout);
   /* Do not write the write_data_filename */
+  /* Do not write the log_csv_filename */
 }
 
 static ScsSettings *read_scs_stgs(FILE *fin) {
@@ -64,12 +77,15 @@ static ScsSettings *read_scs_stgs(FILE *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);
-  fread(&(s->eps), sizeof(scs_float), 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->cg_rate), 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);
   return s;
 }
 
@@ -98,15 +114,21 @@ static ScsMatrix *read_amatrix(FILE *fin) {
 }
 
 static void write_scs_data(const ScsData *d, FILE *fout) {
+  scs_int has_p = d->P ? 1 : 0;
   fwrite(&(d->m), sizeof(scs_int), 1, fout);
   fwrite(&(d->n), sizeof(scs_int), 1, fout);
   fwrite(d->b, sizeof(scs_float), d->m, fout);
   fwrite(d->c, sizeof(scs_float), d->n, fout);
-  write_scs_stgs(d->stgs, fout);
   write_amatrix(d->A, fout);
+  /* write has P bit */
+  fwrite(&has_p, sizeof(scs_int), 1, fout);
+  if (d->P) {
+    write_amatrix(d->P, fout);
+  }
 }
 
 static ScsData *read_scs_data(FILE *fin) {
+  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);
@@ -114,26 +136,37 @@ static ScsData *read_scs_data(FILE *fin) {
   d->c = 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->stgs = read_scs_stgs(fin);
   d->A = read_amatrix(fin);
+  /* 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;
   return d;
 }
 
-void SCS(write_data)(const ScsData *d, const ScsCone *k) {
-  FILE *fout = fopen(d->stgs->write_data_filename, "wb");
-  uint32_t scs_int_sz = (uint32_t)sizeof(scs_int);
-  uint32_t scs_float_sz = (uint32_t)sizeof(scs_float);
-  scs_printf("writing data to %s\n", d->stgs->write_data_filename);
+void SCS(write_data)(const ScsData *d, const ScsCone *k,
+                     const ScsSettings *stgs) {
+  FILE *fout = fopen(stgs->write_data_filename, "wb");
+  uint32_t scs_int_sz = (uint32_t)SCS(sizeof_int)();
+  uint32_t scs_float_sz = (uint32_t)SCS(sizeof_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);
+  fwrite(scs_version, 1, scs_version_sz, fout);
   write_scs_cone(k, fout);
   write_scs_data(d, fout);
+  write_scs_stgs(stgs, fout);
   fclose(fout);
 }
 
-scs_int SCS(read_data)(const char *filename, ScsData **d, ScsCone **k) {
+scs_int SCS(read_data)(const char *filename, ScsData **d, ScsCone **k,
+                       ScsSettings **stgs) {
   uint32_t file_int_sz;
   uint32_t file_float_sz;
+  uint32_t file_version_sz;
+  char file_version[16];
   FILE *fin = fopen(filename, "rb");
   if (!fin) {
     scs_printf("Error reading file %s\n", filename);
@@ -142,26 +175,132 @@ scs_int SCS(read_data)(const char *filename, ScsData **d, ScsCone **k) {
   scs_printf("Reading data from %s\n", filename);
   fread(&(file_int_sz), sizeof(uint32_t), 1, fin);
   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",
+        "Error, sizeof(file int) is %lu, but scs expects sizeof(int) %lu, "
+        "scs should be recompiled with 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(
-        "Error, sizeof(file float) is %lu, but scs expects "
-        "sizeof(float) %lu, scs should be recompiled with the correct flags.\n",
+        "Error, sizeof(file float) is %lu, but scs expects sizeof(float) %lu, "
+        "scs should be recompiled with the correct flags.\n",
         (unsigned long)file_float_sz, (unsigned long)sizeof(scs_float));
     fclose(fin);
     return -1;
   }
-
+  fread(&(file_version_sz), sizeof(uint32_t), 1, fin);
+  fread(file_version, 1, file_version_sz, fin);
+  file_version[file_version_sz] = '\0';
+  if (strcmp(file_version, SCS_VERSION) != 0) {
+    scs_printf("************************************************************\n"
+               "Warning: SCS file version %s, this is SCS version %s.\n"
+               "The file reading / writing logic might have changed.\n"
+               "************************************************************\n",
+               file_version, SCS_VERSION);
+  }
   *k = read_scs_cone(fin);
   *d = read_scs_data(fin);
+  *stgs = read_scs_stgs(fin);
   fclose(fin);
   return 0;
 }
+
+void SCS(log_data_to_csv)(const ScsData *d, const ScsCone *k,
+                          const ScsSettings *stgs, const ScsWork *w,
+                          scs_int iter, SCS(timer) * solve_timer) {
+  ScsResiduals *r = w->r_orig;
+  ScsResiduals *r_n = w->r_normalized;
+  /* if iter 0 open to write, else open to append */
+  FILE *fout = fopen(stgs->log_csv_filename, iter == 0 ? "w" : "a");
+  if (!fout) {
+    scs_printf("Error: Could not open %s for writing\n",
+               stgs->log_csv_filename);
+    return;
+  }
+  scs_int l = w->m + w->n + 1;
+  if (iter == 0) {
+    /* need to end in comma so that csv parsing is correct */
+    fprintf(fout, "iter,"
+                  "res_pri,"
+                  "res_dual,"
+                  "gap,"
+                  "ax_s_btau_nrm_inf,"
+                  "px_aty_ctau_nrm_inf,"
+                  "ax_s_btau_nrm_2,"
+                  "px_aty_ctau_nrm_2,"
+                  "res_infeas,"
+                  "res_unbdd_a,"
+                  "res_unbdd_p,"
+                  "pobj,"
+                  "dobj,"
+                  "tau,"
+                  "kap,"
+                  "res_pri_normalized,"
+                  "res_dual_normalized,"
+                  "gap_normalized,"
+                  "ax_s_btau_nrm_inf_normalized,"
+                  "px_aty_ctau_nrm_inf_normalized,"
+                  "ax_s_btau_nrm_2_normalized,"
+                  "px_aty_ctau_nrm_2_normalized,"
+                  "res_infeas_normalized,"
+                  "res_unbdd_a_normalized,"
+                  "res_unbdd_p_normalized,"
+                  "pobj_normalized,"
+                  "dobj_normalized,"
+                  "tau_normalized,"
+                  "kap_normalized,"
+                  "scale,"
+                  "diff_u_ut_nrm_2,"
+                  "diff_v_v_prev_nrm_2,"
+                  "diff_u_ut_nrm_inf,"
+                  "diff_v_v_prev_nrm_inf,"
+                  "aa_norm,"
+                  "accepted_accel_steps,"
+                  "rejected_accel_steps,"
+                  "time,"
+                  "\n");
+  }
+  fprintf(fout, "%li,", (long)iter);
+  fprintf(fout, "%.16e,", r->res_pri);
+  fprintf(fout, "%.16e,", r->res_dual);
+  fprintf(fout, "%.16e,", r->gap);
+  fprintf(fout, "%.16e,", SCS(norm_inf)(r->ax_s_btau, w->m));
+  fprintf(fout, "%.16e,", SCS(norm_inf)(r->px_aty_ctau, w->n));
+  fprintf(fout, "%.16e,", SCS(norm_2)(r->ax_s_btau, w->m));
+  fprintf(fout, "%.16e,", SCS(norm_2)(r->px_aty_ctau, w->n));
+  fprintf(fout, "%.16e,", r->res_infeas);
+  fprintf(fout, "%.16e,", r->res_unbdd_a);
+  fprintf(fout, "%.16e,", r->res_unbdd_p);
+  fprintf(fout, "%.16e,", r->pobj);
+  fprintf(fout, "%.16e,", r->dobj);
+  fprintf(fout, "%.16e,", r->tau);
+  fprintf(fout, "%.16e,", r->kap);
+  fprintf(fout, "%.16e,", r_n->res_pri);
+  fprintf(fout, "%.16e,", r_n->res_dual);
+  fprintf(fout, "%.16e,", r_n->gap);
+  fprintf(fout, "%.16e,", SCS(norm_inf)(r_n->ax_s_btau, w->m));
+  fprintf(fout, "%.16e,", SCS(norm_inf)(r_n->px_aty_ctau, w->n));
+  fprintf(fout, "%.16e,", SCS(norm_2)(r_n->ax_s_btau, w->m));
+  fprintf(fout, "%.16e,", SCS(norm_2)(r_n->px_aty_ctau, w->n));
+  fprintf(fout, "%.16e,", r_n->res_infeas);
+  fprintf(fout, "%.16e,", r_n->res_unbdd_a);
+  fprintf(fout, "%.16e,", r_n->res_unbdd_p);
+  fprintf(fout, "%.16e,", r_n->pobj);
+  fprintf(fout, "%.16e,", r_n->dobj);
+  fprintf(fout, "%.16e,", r_n->tau);
+  fprintf(fout, "%.16e,", r_n->kap);
+  fprintf(fout, "%.16e,", w->scale);
+  fprintf(fout, "%.16e,", SCS(norm_diff)(w->u, w->u_t, l));
+  fprintf(fout, "%.16e,", SCS(norm_diff)(w->v, w->v_prev, l));
+  fprintf(fout, "%.16e,", SCS(norm_inf_diff)(w->u, w->u_t, l));
+  fprintf(fout, "%.16e,", SCS(norm_inf_diff)(w->v, w->v_prev, l));
+  fprintf(fout, "%.16e,", w->aa_norm);
+  fprintf(fout, "%li,", (long)w->accepted_accel_steps);
+  fprintf(fout, "%li,", (long)w->rejected_accel_steps);
+  fprintf(fout, "%.16e,", SCS(tocq)(solve_timer) / 1e3);
+  fprintf(fout, "\n");
+  fclose(fout);
+}