scs 0.3.1 → 0.3.2

data/vendor/scs/src/cones.c

@@ -10,18 +10,15 @@
 #define BOX_CONE_MAX_ITERS (25)
 #define POW_CONE_MAX_ITERS (20)
 
-/* In the box cone projection we penalize the `t` term additionally by this
- * factor. This encourages the `t` term to stay close to the incoming `t` term,
- * which should provide better convergence since typically the `t` term does
- * not appear in the linear system other than `t = 1`. Setting to 1 is
- * the vanilla projection.
- */
-#define BOX_T_SCALE (1.)
-
 /* Box cone limits (+ or -) taken to be INF */
 #define MAX_BOX_VAL (1e15)
 
 #ifdef USE_LAPACK
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 void BLAS(syev)(const char *jobz, const char *uplo, blas_int *n, scs_float *a,
                 blas_int *lda, scs_float *w, scs_float *work, blas_int *lwork,
                 blas_int *info);
@@ -31,34 +28,43 @@ blas_int BLAS(syrk)(const char *uplo, const char *trans, const blas_int *n,
                     const scs_float *beta, scs_float *c, const blas_int *ldc);
 void BLAS(scal)(const blas_int *n, const scs_float *sa, scs_float *sx,
                 const blas_int *incx);
+
+#ifdef __cplusplus
+}
+#endif
+
 #endif
 
 /* set the vector of rho y terms, based on scale and cones */
-void SCS(set_rho_y_vec)(const ScsCone *k, scs_float scale, scs_float *rho_y_vec,
-                        scs_int m) {
-  scs_int i, count = 0;
-  /* f cone */
-  for (i = 0; i < k->z; ++i) {
+void SCS(set_r_y)(const ScsConeWork *c, scs_float scale, scs_float *r_y) {
+  scs_int i;
+  /* z cone */
+  for (i = 0; i < c->k->z; ++i) {
     /* set rho_y small for z, similar to rho_x term, since z corresponds to
      * dual free cone, this effectively decreases penalty on those entries
      * and lets them be determined almost entirely by the linear system solve
      */
-    rho_y_vec[i] = 1.0 / (1000. * scale);
+    r_y[i] = 1.0 / (1000. * scale);
   }
-  count += k->z;
   /* others */
-  for (i = count; i < m; ++i) {
-    rho_y_vec[i] = 1.0 / scale;
+  for (i = c->k->z; i < c->m; ++i) {
+    r_y[i] = 1.0 / scale;
   }
+}
 
-  /* Note, if updating this to use different scales for other cones (e.g. box)
-   * then you must be careful to also include the effect of the rho_y_vec
-   * in the cone projection operator.
-   */
-
-  /* Increase rho_y_vec for the t term in the box cone */
-  if (k->bsize) {
-    rho_y_vec[k->z + k->l] *= BOX_T_SCALE;
+/* the function f aggregates the entries within each cone */
+void SCS(enforce_cone_boundaries)(const ScsConeWork *c, scs_float *vec,
+                                  scs_float (*f)(const scs_float *, scs_int)) {
+  scs_int i, j, delta;
+  scs_int count = c->cone_boundaries[0];
+  scs_float wrk;
+  for (i = 1; i < c->cone_boundaries_len; ++i) {
+    delta = c->cone_boundaries[i];
+    wrk = f(&(vec[count]), delta);
+    for (j = count; j < count + delta; ++j) {
+      vec[j] = wrk;
+    }
+    count += delta;
   }
 }
 
@@ -71,7 +77,7 @@ static inline scs_int get_sd_cone_size(scs_int s) {
  * cone boundaries, boundaries[0] is starting index for cones of size strictly
  * larger than 1, boundaries malloc-ed here so should be freed.
  */
-scs_int SCS(set_cone_boundaries)(const ScsCone *k, scs_int **cone_boundaries) {
+void set_cone_boundaries(const ScsCone *k, ScsConeWork *c) {
   scs_int i, s_cone_sz, count = 0;
   scs_int cone_boundaries_len =
       1 + k->qsize + k->ssize + k->ed + k->ep + k->psize;
@@ -99,8 +105,8 @@ scs_int SCS(set_cone_boundaries)(const ScsCone *k, scs_int **cone_boundaries) {
   }
   count += k->psize;
   /* other cones */
-  *cone_boundaries = b;
-  return cone_boundaries_len;
+  c->cone_boundaries = b;
+  c->cone_boundaries_len = cone_boundaries_len;
 }
 
 static scs_int get_full_cone_dims(const ScsCone *k) {
@@ -121,7 +127,7 @@ static scs_int get_full_cone_dims(const ScsCone *k) {
   if (k->ep) {
     c += 3 * k->ep;
   }
-  if (k->p) {
+  if (k->psize) {
     c += 3 * k->psize;
   }
   return c;
@@ -216,6 +222,9 @@ void SCS(finish_cone)(ScsConeWork *c) {
     scs_free(c->work);
   }
 #endif
+  if (c->cone_boundaries) {
+    scs_free(c->cone_boundaries);
+  }
   if (c->s) {
     scs_free(c->s);
   }
@@ -484,7 +493,7 @@ static scs_int proj_semi_definite_cone(scs_float *X, const scs_int n,
   /* Solve eigenproblem, reuse workspaces */
   BLAS(syev)("Vectors", "Lower", &nb, Xs, &nb, e, work, &lwork, &info);
   if (info != 0) {
-    scs_printf("WARN: LAPACK syev error, info = %i\n", info);
+    scs_printf("WARN: LAPACK syev error, info = %i\n", (int)info);
     if (info < 0) {
       return info;
     }
@@ -587,36 +596,40 @@ static void normalize_box_cone(ScsConeWork *c, scs_float *D, scs_int bsize) {
   }
 }
 
-/* project onto { (t, s) | t * l <= s <= t * u, t >= 0 }, Newton's method on t
-   tx = [t; s], total length = bsize
-   uses Moreau since \Pi_K*(tx) = \Pi_K(-tx) + tx
+/* Project onto { (t, s) | t * l <= s <= t * u, t >= 0 }, Newton's method on t
+   tx = [t; s], total length = bsize, under Euclidean metric 1/r_box.
 */
 static scs_float proj_box_cone(scs_float *tx, const scs_float *bl,
                                const scs_float *bu, scs_int bsize,
-                               scs_float t_warm_start) {
+                               scs_float t_warm_start, scs_float *r_box) {
   scs_float *x, gt, ht, t_prev, t = t_warm_start;
+  scs_float rho_t = 1, *rho = SCS_NULL, r;
   scs_int iter, j;
 
   if (bsize == 1) { /* special case */
     tx[0] = MAX(tx[0], 0.0);
     return tx[0];
   }
-
   x = &(tx[1]);
 
+  if (r_box) {
+    rho_t = 1.0 / r_box[0];
+    rho = &(r_box[1]);
+  }
+
   /* should only require about 5 or so iterations, 1 or 2 if warm-started */
   for (iter = 0; iter < BOX_CONE_MAX_ITERS; iter++) {
     t_prev = t;
-    /* incorporate the additional BOX_T_SCALE factor into the projection */
-    gt = BOX_T_SCALE * (t - tx[0]); /* gradient */
-    ht = BOX_T_SCALE;               /* hessian */
+    gt = rho_t * (t - tx[0]); /* gradient */
+    ht = rho_t;               /* hessian */
     for (j = 0; j < bsize - 1; j++) {
+      r = rho ? 1.0 / rho[j] : 1.;
       if (x[j] > t * bu[j]) {
-        gt += (t * bu[j] - x[j]) * bu[j]; /* gradient */
-        ht += bu[j] * bu[j];              /* hessian */
+        gt += r * (t * bu[j] - x[j]) * bu[j]; /* gradient */
+        ht += r * bu[j] * bu[j];              /* hessian */
       } else if (x[j] < t * bl[j]) {
-        gt += (t * bl[j] - x[j]) * bl[j]; /* gradient */
-        ht += bl[j] * bl[j];              /* hessian */
+        gt += r * (t * bl[j] - x[j]) * bl[j]; /* gradient */
+        ht += r * bl[j] * bl[j];              /* hessian */
       }
     }
     t = MAX(t - gt / MAX(ht, 1e-8), 0.); /* newton step */
@@ -647,6 +660,7 @@ static scs_float proj_box_cone(scs_float *tx, const scs_float *bl,
     /* x[j] unchanged otherwise */
   }
   tx[0] = t;
+
 #if VERBOSITY > 3
   scs_printf("box cone iters %i\n", (int)iter + 1);
 #endif
@@ -718,18 +732,23 @@ static void proj_power_cone(scs_float *v, scs_float a) {
 }
 
 /* project onto the primal K cone in the paper */
+/* the r_y vector determines the INVERSE metric, ie, project under the
+ * diag(r_y)^-1 norm.
+ */
 static scs_int proj_cone(scs_float *x, const ScsCone *k, ScsConeWork *c,
-                         scs_int normalize) {
+                         scs_int normalize, scs_float *r_y) {
   scs_int i, status;
   scs_int count = 0;
+  scs_float *r_box = SCS_NULL;
+  scs_float *bu, *bl;
 
-  if (k->z) {
+  if (k->z) { /* doesn't use r_y */
     /* project onto primal zero / dual free cone */
     memset(x, 0, k->z * sizeof(scs_float));
     count += k->z;
   }
 
-  if (k->l) {
+  if (k->l) { /* doesn't use r_y */
     /* project onto positive orthant */
     for (i = count; i < count + k->l; ++i) {
       x[i] = MAX(x[i], 0.0);
@@ -737,19 +756,19 @@ static scs_int proj_cone(scs_float *x, const ScsCone *k, ScsConeWork *c,
     count += k->l;
   }
 
-  if (k->bsize) {
-    /* project onto box cone */
-    if (normalize) {
-      c->box_t_warm_start = proj_box_cone(&(x[count]), c->bl, c->bu, k->bsize,
-                                          c->box_t_warm_start);
-    } else {
-      c->box_t_warm_start = proj_box_cone(&(x[count]), k->bl, k->bu, k->bsize,
-                                          c->box_t_warm_start);
+  if (k->bsize) { /* DOES use r_y */
+    if (r_y) {
+      r_box = &(r_y[count]);
     }
+    /* project onto box cone */
+    bu = normalize ? c->bu : k->bu;
+    bl = normalize ? c->bl : k->bl;
+    c->box_t_warm_start = proj_box_cone(&(x[count]), bl, bu, k->bsize,
+                                        c->box_t_warm_start, r_box);
     count += k->bsize; /* since b = (t,s), len(s) = bsize - 1 */
   }
 
-  if (k->qsize && k->q) {
+  if (k->qsize && k->q) { /* doesn't use r_y */
     /* project onto second-order cones */
     for (i = 0; i < k->qsize; ++i) {
       proj_soc(&(x[count]), k->q[i]);
@@ -757,7 +776,7 @@ static scs_int proj_cone(scs_float *x, const ScsCone *k, ScsConeWork *c,
     }
   }
 
-  if (k->ssize && k->s) {
+  if (k->ssize && k->s) { /* doesn't use r_y */
     /* project onto PSD cones */
     for (i = 0; i < k->ssize; ++i) {
       status = proj_semi_definite_cone(&(x[count]), k->s[i], c);
@@ -768,13 +787,13 @@ static scs_int proj_cone(scs_float *x, const ScsCone *k, ScsConeWork *c,
     }
   }
 
-  if (k->ep) {
-    /*
-     * exponential cone is not self dual, if s \in K
-     * then y \in K^* and so if K is the primal cone
-     * here we project onto K^*, via Moreau
-     * \Pi_C^*(y) = y + \Pi_C(-y)
-     */
+  if (k->ep) { /* doesn't use r_y */
+               /*
+                * exponential cone is not self dual, if s \in K
+                * then y \in K^* and so if K is the primal cone
+                * here we project onto K^*, via Moreau
+                * \Pi_C^*(y) = y + \Pi_C(-y)
+                */
 #ifdef _OPENMP
 #pragma omp parallel for
 #endif
@@ -784,7 +803,8 @@ static scs_int proj_cone(scs_float *x, const ScsCone *k, ScsConeWork *c,
     count += 3 * k->ep;
   }
 
-  if (k->ed) { /* dual exponential cone */
+  /* dual exponential cone */
+  if (k->ed) { /* doesn't use r_y */
     /*
      * exponential cone is not self dual, if s \in K
      * then y \in K^* and so if K is the primal cone
@@ -812,7 +832,7 @@ static scs_int proj_cone(scs_float *x, const ScsCone *k, ScsConeWork *c,
     count += 3 * k->ed;
   }
 
-  if (k->psize && k->p) {
+  if (k->psize && k->p) { /* doesn't use r_y */
     scs_float v[3];
     scs_int idx;
     /* don't use openmp for power cone
@@ -820,7 +840,7 @@ static scs_int proj_cone(scs_float *x, const ScsCone *k, ScsConeWork *c,
     pragma omp parallel for private(v, idx)
     endif
     */
-    for (i = 0; i < k->psize; ++i) {
+    for (i = 0; i < k->psize; ++i) { /* doesn't use r_y */
       idx = count + 3 * i;
       if (k->p[i] >= 0) {
         /* primal power cone */
@@ -844,11 +864,23 @@ static scs_int proj_cone(scs_float *x, const ScsCone *k, ScsConeWork *c,
   return 0;
 }
 
-ScsConeWork *SCS(init_cone)(const ScsCone *k, const ScsScaling *scal,
-                            scs_int cone_len) {
+ScsConeWork *SCS(init_cone)(const ScsCone *k, scs_int m) {
   ScsConeWork *c = (ScsConeWork *)scs_calloc(1, sizeof(ScsConeWork));
-  c->cone_len = cone_len;
-  c->s = (scs_float *)scs_calloc(cone_len, sizeof(scs_float));
+  c->k = k;
+  c->m = m;
+  c->scaled_cones = 0;
+  set_cone_boundaries(k, c);
+  c->s = (scs_float *)scs_calloc(m, sizeof(scs_float));
+  if (k->ssize && k->s) {
+    if (set_up_sd_cone_work_space(c, k) < 0) {
+      SCS(finish_cone)(c);
+      return SCS_NULL;
+    }
+  }
+  return c;
+}
+
+void scale_box_cone(const ScsCone *k, ScsConeWork *c, ScsScaling *scal) {
   if (k->bsize && k->bu && k->bl) {
     c->box_t_warm_start = 1.;
     if (scal) {
@@ -857,33 +889,52 @@ ScsConeWork *SCS(init_cone)(const ScsCone *k, const ScsScaling *scal,
       memcpy(c->bu, k->bu, (k->bsize - 1) * sizeof(scs_float));
       memcpy(c->bl, k->bl, (k->bsize - 1) * sizeof(scs_float));
       /* also does some sanitizing */
-      normalize_box_cone(c, scal ? &(scal->D[k->z + k->l]) : SCS_NULL,
-                         k->bsize);
-    }
-  }
-  if (k->ssize && k->s) {
-    if (set_up_sd_cone_work_space(c, k) < 0) {
-      SCS(finish_cone)(c);
-      return SCS_NULL;
+      normalize_box_cone(c, &(scal->D[k->z + k->l]), k->bsize);
     }
   }
-  return c;
 }
 
-/* outward facing cone projection routine
-   performs projection in-place
-   if normalize > 0 then will use normalized (equilibrated) cones if applicable.
+/* Outward facing cone projection routine, performs projection in-place.
+   If normalize > 0 then will use normalized (equilibrated) cones if applicable.
+
+   Moreau decomposition for R-norm projections:
+
+    `x + R^{-1} \Pi_{C^*}^{R^{-1}} ( - R x ) = \Pi_C^R ( x )`
+
+   where \Pi^R_C is the projection onto C under the R-norm:
+
+    `||x||_R = \sqrt{x ' R x}`.
+
 */
-scs_int SCS(proj_dual_cone)(scs_float *x, const ScsCone *k, ScsConeWork *c,
-                            scs_int normalize) {
-  scs_int status;
-  /* copy x, s = x */
-  memcpy(c->s, x, c->cone_len * sizeof(scs_float));
-  /* negate x -> -x */
-  SCS(scale_array)(x, -1., c->cone_len);
-  /* project -x onto cone, x -> Pi_K(-x) */
-  status = proj_cone(x, k, c, normalize);
-  /* return Pi_K*(x) = s + Pi_K(-x) */
-  SCS(add_scaled_array)(x, c->s, c->cone_len, 1.);
+scs_int SCS(proj_dual_cone)(scs_float *x, ScsConeWork *c, ScsScaling *scal,
+                            scs_float *r_y) {
+  scs_int status, i;
+  const ScsCone *k = c->k;
+
+  if (!c->scaled_cones) {
+    scale_box_cone(k, c, scal);
+    c->scaled_cones = 1;
+  }
+
+  /* copy s = x */
+  memcpy(c->s, x, c->m * sizeof(scs_float));
+
+  /* x -> - Rx */
+  for (i = 0; i < c->m; ++i) {
+    x[i] *= r_y ? -r_y[i] : -1;
+  }
+
+  /* project -x onto cone, x -> \Pi_{C^*}^{R^{-1}}(-x) under r_y metric */
+  status = proj_cone(x, k, c, scal ? 1 : 0, r_y);
+
+  /* return x + R^{-1} \Pi_{C^*}^{R^{-1}} ( -x )  */
+  for (i = 0; i < c->m; ++i) {
+    if (r_y) {
+      x[i] = x[i] / r_y[i] + c->s[i];
+    } else {
+      x[i] += c->s[i];
+    }
+  }
+
   return status;
 }

data/vendor/scs/src/linalg.c

@@ -83,9 +83,22 @@ void SCS(add_scaled_array)(scs_float *a, const scs_float *b, scs_int n,
   }
 }
 
+scs_float SCS(mean)(const scs_float *x, scs_int n) {
+  scs_int i;
+  scs_float mean = 0.;
+  for (i = 0; i < n; ++i) {
+    mean += x[i];
+  }
+  return mean / n;
+}
+
 #else
 /* If we have BLAS / LAPACK we may as well use them */
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 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);
@@ -96,6 +109,10 @@ void BLAS(axpy)(blas_int *n, const scs_float *a, const scs_float *x,
 void BLAS(scal)(const blas_int *n, const scs_float *sa, scs_float *sx,
                 const blas_int *incx);
 
+#ifdef __cplusplus
+}
+#endif
+
 /* a *= b */
 void SCS(scale_array)(scs_float *a, const scs_float b, scs_int len) {
   blas_int bone = 1;
@@ -137,4 +154,12 @@ void SCS(add_scaled_array)(scs_float *a, const scs_float *b, scs_int len,
   BLAS(axpy)(&blen, &sc, b, &bone, a, &bone);
 }
 
+scs_float SCS(mean)(const scs_float *x, scs_int n) {
+  blas_int bone = 1;
+  blas_int bzero = 0;
+  blas_int blen = (blas_int)n;
+  scs_float y = 1.0;
+  return BLAS(dot)(&blen, x, &bone, &y, &bzero) / n;
+}
+
 #endif

data/vendor/scs/src/normalize.c

@@ -4,48 +4,48 @@
 #include "scs.h"
 
 /* needed for normalizing the warm-start */
-void SCS(normalize_sol)(ScsWork *w, ScsSolution *sol) {
+void SCS(normalize_sol)(ScsScaling *scal, ScsSolution *sol) {
   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->scal->dual_scale);
+  scs_float *D = scal->D;
+  scs_float *E = scal->E;
+  for (i = 0; i < scal->n; ++i) {
+    sol->x[i] /= (E[i] / scal->dual_scale);
   }
-  for (i = 0; i < w->m; ++i) {
-    sol->y[i] /= (D[i] / w->scal->primal_scale);
+  for (i = 0; i < scal->m; ++i) {
+    sol->y[i] /= (D[i] / scal->primal_scale);
   }
-  for (i = 0; i < w->m; ++i) {
-    sol->s[i] *= (D[i] * w->scal->dual_scale);
+  for (i = 0; i < scal->m; ++i) {
+    sol->s[i] *= (D[i] * scal->dual_scale);
   }
 }
 
-void SCS(un_normalize_sol)(ScsWork *w, ScsSolution *sol) {
+void SCS(un_normalize_sol)(ScsScaling *scal, ScsSolution *sol) {
   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->scal->dual_scale);
+  scs_float *D = scal->D;
+  scs_float *E = scal->E;
+  for (i = 0; i < scal->n; ++i) {
+    sol->x[i] *= (E[i] / scal->dual_scale);
   }
-  for (i = 0; i < w->m; ++i) {
-    sol->y[i] *= (D[i] / w->scal->primal_scale);
+  for (i = 0; i < scal->m; ++i) {
+    sol->y[i] *= (D[i] / scal->primal_scale);
   }
-  for (i = 0; i < w->m; ++i) {
-    sol->s[i] /= (D[i] * w->scal->dual_scale);
+  for (i = 0; i < scal->m; ++i) {
+    sol->s[i] /= (D[i] * scal->dual_scale);
   }
 }
 
-void SCS(un_normalize_primal)(ScsWork *w, scs_float *r) {
+void SCS(un_normalize_primal)(ScsScaling *scal, scs_float *r) {
   scs_int i;
-  scs_float *D = w->scal->D;
-  for (i = 0; i < w->m; ++i) {
-    r[i] /= (D[i] * w->scal->dual_scale);
+  scs_float *D = scal->D;
+  for (i = 0; i < scal->m; ++i) {
+    r[i] /= (D[i] * scal->dual_scale);
   }
 }
 
-void SCS(un_normalize_dual)(ScsWork *w, scs_float *r) {
+void SCS(un_normalize_dual)(ScsScaling *scal, 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);
+  scs_float *E = scal->E;
+  for (i = 0; i < scal->n; ++i) {
+    r[i] /= (E[i] * scal->primal_scale);
   }
 }

data/vendor/scs/src/rw.c

@@ -33,20 +33,20 @@ static ScsCone *read_scs_cone(FILE *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));
+  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);
-  k->q = scs_calloc(k->qsize, sizeof(scs_int));
+  k->q = (scs_int *)scs_calloc(k->qsize, sizeof(scs_int));
   fread(k->q, sizeof(scs_int), k->qsize, fin);
   fread(&(k->ssize), sizeof(scs_int), 1, fin);
-  k->s = scs_calloc(k->ssize, sizeof(scs_int));
+  k->s = (scs_int *)scs_calloc(k->ssize, sizeof(scs_int));
   fread(k->s, sizeof(scs_int), 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);
-  k->p = scs_calloc(k->psize, sizeof(scs_float));
+  k->p = (scs_float *)scs_calloc(k->psize, sizeof(scs_float));
   fread(k->p, sizeof(scs_float), k->psize, fin);
   return k;
 }
@@ -103,11 +103,11 @@ static ScsMatrix *read_amatrix(FILE *fin) {
   ScsMatrix *A = (ScsMatrix *)scs_calloc(1, sizeof(ScsMatrix));
   fread(&(A->m), sizeof(scs_int), 1, fin);
   fread(&(A->n), sizeof(scs_int), 1, fin);
-  A->p = scs_calloc(A->n + 1, sizeof(scs_int));
+  A->p = (scs_int *)scs_calloc(A->n + 1, sizeof(scs_int));
   fread(A->p, sizeof(scs_int), A->n + 1, fin);
   Anz = A->p[A->n];
-  A->x = scs_calloc(Anz, sizeof(scs_float));
-  A->i = scs_calloc(Anz, sizeof(scs_int));
+  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);
   return A;
@@ -132,8 +132,8 @@ static ScsData *read_scs_data(FILE *fin) {
   ScsData *d = (ScsData *)scs_calloc(1, sizeof(ScsData));
   fread(&(d->m), sizeof(scs_int), 1, fin);
   fread(&(d->n), sizeof(scs_int), 1, fin);
-  d->b = scs_calloc(d->m, sizeof(scs_float));
-  d->c = scs_calloc(d->n, sizeof(scs_float));
+  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);
@@ -146,8 +146,8 @@ static ScsData *read_scs_data(FILE *fin) {
 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)();
+  uint32_t scs_int_sz = (uint32_t)sizeof(scs_int);
+  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);
@@ -213,6 +213,8 @@ void SCS(log_data_to_csv)(const ScsData *d, const ScsCone *k,
                           scs_int iter, SCS(timer) * solve_timer) {
   ScsResiduals *r = w->r_orig;
   ScsResiduals *r_n = w->r_normalized;
+  ScsSolution *sol = w->xys_orig;
+  ScsSolution *sol_n = w->xys_normalized;
   /* if iter 0 open to write, else open to append */
   FILE *fout = fopen(stgs->log_csv_filename, iter == 0 ? "w" : "a");
   if (!fout) {
@@ -227,6 +229,18 @@ void SCS(log_data_to_csv)(const ScsData *d, const ScsCone *k,
                   "res_pri,"
                   "res_dual,"
                   "gap,"
+                  "x_nrm_inf,"
+                  "y_nrm_inf,"
+                  "s_nrm_inf,"
+                  "x_nrm_2,"
+                  "y_nrm_2,"
+                  "s_nrm_2,"
+                  "x_nrm_inf_normalized,"
+                  "y_nrm_inf_normalized,"
+                  "s_nrm_inf_normalized,"
+                  "x_nrm_2_normalized,"
+                  "y_nrm_2_normalized,"
+                  "s_nrm_2_normalized,"
                   "ax_s_btau_nrm_inf,"
                   "px_aty_ctau_nrm_inf,"
                   "ax_s_btau_nrm_2,"
@@ -252,6 +266,11 @@ void SCS(log_data_to_csv)(const ScsData *d, const ScsCone *k,
                   "dobj_normalized,"
                   "tau_normalized,"
                   "kap_normalized,"
+                  "ax_nrm_inf,"
+                  "px_nrm_inf,"
+                  "aty_nrm_inf,"
+                  "b_nrm_inf,"
+                  "c_nrm_inf,"
                   "scale,"
                   "diff_u_ut_nrm_2,"
                   "diff_v_v_prev_nrm_2,"
@@ -267,6 +286,18 @@ void SCS(log_data_to_csv)(const ScsData *d, const ScsCone *k,
   fprintf(fout, "%.16e,", r->res_pri);
   fprintf(fout, "%.16e,", r->res_dual);
   fprintf(fout, "%.16e,", r->gap);
+  fprintf(fout, "%.16e,", SCS(norm_inf)(sol->x, w->n));
+  fprintf(fout, "%.16e,", SCS(norm_inf)(sol->y, w->m));
+  fprintf(fout, "%.16e,", SCS(norm_inf)(sol->s, w->m));
+  fprintf(fout, "%.16e,", SCS(norm_2)(sol->x, w->n));
+  fprintf(fout, "%.16e,", SCS(norm_2)(sol->y, w->m));
+  fprintf(fout, "%.16e,", SCS(norm_2)(sol->s, w->m));
+  fprintf(fout, "%.16e,", SCS(norm_inf)(sol_n->x, w->n));
+  fprintf(fout, "%.16e,", SCS(norm_inf)(sol_n->y, w->m));
+  fprintf(fout, "%.16e,", SCS(norm_inf)(sol_n->s, w->m));
+  fprintf(fout, "%.16e,", SCS(norm_2)(sol_n->x, w->n));
+  fprintf(fout, "%.16e,", SCS(norm_2)(sol_n->y, w->m));
+  fprintf(fout, "%.16e,", SCS(norm_2)(sol_n->s, w->m));
   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));
@@ -292,6 +323,11 @@ void SCS(log_data_to_csv)(const ScsData *d, const ScsCone *k,
   fprintf(fout, "%.16e,", r_n->dobj);
   fprintf(fout, "%.16e,", r_n->tau);
   fprintf(fout, "%.16e,", r_n->kap);
+  fprintf(fout, "%.16e,", SCS(norm_inf)(r->ax, w->m));
+  fprintf(fout, "%.16e,", SCS(norm_inf)(r->px, w->n));
+  fprintf(fout, "%.16e,", SCS(norm_inf)(r->aty, w->n));
+  fprintf(fout, "%.16e,", SCS(norm_inf)(w->b_orig, w->m));
+  fprintf(fout, "%.16e,", SCS(norm_inf)(w->c_orig, w->n));
   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));