scs 0.3.2 → 0.4.0

data/vendor/scs/linsys/external/amd/SuiteSparse_config.c

@@ -50,7 +50,9 @@
 
 struct SuiteSparse_config_struct SuiteSparse_config =
 {
-    scs_malloc, scs_calloc, scs_realloc, scs_free, _scs_printf,
+    scs_malloc, scs_calloc, scs_realloc, scs_free,
+    /* Disable printing */
+    SCS_NULL,
     SuiteSparse_hypot,
     SuiteSparse_divcomplex
 
@@ -79,7 +81,7 @@ void SuiteSparse_start ( void )
     SuiteSparse_config.calloc_func  = scs_calloc ;
     SuiteSparse_config.realloc_func = scs_realloc ;
     SuiteSparse_config.free_func    = scs_free ;
-    SuiteSparse_config.printf_func  = _scs_printf ;
+    SuiteSparse_config.printf_func  = SCS_NULL;
     /* math functions */
     SuiteSparse_config.hypot_func = SuiteSparse_hypot ;
     SuiteSparse_config.divcomplex_func = SuiteSparse_divcomplex ;

data/vendor/scs/linsys/external/amd/SuiteSparse_config.h

@@ -71,11 +71,6 @@ extern "C" {
 #define SuiteSparse_long_id "%" SuiteSparse_long_idd
 #endif
 
-#ifndef _scs_printf
-#define _scs_printf scs_printf
-#endif
-
-
 /* ========================================================================== */
 /* === SuiteSparse_config parameters and functions ========================== */
 /* ========================================================================== */

data/vendor/scs/linsys/scs_matrix.c

@@ -10,6 +10,10 @@
 #define NUM_L2_PASSES (1)    /* do one or zero, not more since not stable */
 
 scs_int SCS(copy_matrix)(ScsMatrix **dstp, const ScsMatrix *src) {
+  if (!src) {
+    *dstp = SCS_NULL;
+    return 1;
+  }
   scs_int Anz = src->p[src->n];
   ScsMatrix *A = (ScsMatrix *)scs_calloc(1, sizeof(ScsMatrix));
   if (!A) {
@@ -41,6 +45,8 @@ scs_int SCS(validate_lin_sys)(const ScsMatrix *A, const ScsMatrix *P) {
   }
   /* detects some errors in A col ptrs: */
   Anz = A->p[A->n];
+  /* Disable this check which is slowish and typically just produces noise. */
+  /*
   if (Anz > 0) {
     for (i = 0; i < A->n; ++i) {
       if (A->p[i] == A->p[i + 1]) {
@@ -53,6 +59,7 @@ scs_int SCS(validate_lin_sys)(const ScsMatrix *A, const ScsMatrix *P) {
       }
     }
   }
+  */
   if (((scs_float)Anz / A->m > A->n) || (Anz < 0)) {
     scs_printf("Anz (nonzeros in A) = %li, outside of valid range\n",
                (long)Anz);
@@ -106,9 +113,8 @@ static inline scs_float apply_limit(scs_float x) {
   return x;
 }
 
-static void compute_ruiz_mats(ScsMatrix *P, ScsMatrix *A, scs_float *b,
-                              scs_float *c, scs_float *Dt, scs_float *Et,
-                              scs_float *s, ScsConeWork *cone) {
+static void compute_ruiz_mats(ScsMatrix *P, ScsMatrix *A, scs_float *Dt,
+                              scs_float *Et, ScsConeWork *cone) {
   scs_int i, j, kk;
   scs_float wrk;
 
@@ -116,8 +122,8 @@ static void compute_ruiz_mats(ScsMatrix *P, ScsMatrix *A, scs_float *b,
 
   /* initialize D */
   for (i = 0; i < A->m; ++i) {
-    /* Dt[i] = 0.; */
-    Dt[i] = ABS(b[i]);
+    Dt[i] = 0.;
+    /* Dt[i] = ABS(b[i]); */
   }
 
   /* calculate row norms */
@@ -139,8 +145,8 @@ static void compute_ruiz_mats(ScsMatrix *P, ScsMatrix *A, scs_float *b,
 
   /* initialize E */
   for (i = 0; i < A->n; ++i) {
-    /* Et[i] = 0.; */
-    Et[i] = ABS(c[i]);
+    Et[i] = 0.;
+    /* Et[i] = ABS(c[i]); */
   }
 
   /* TODO: test not using P to determine scaling  */
@@ -166,24 +172,19 @@ static void compute_ruiz_mats(ScsMatrix *P, ScsMatrix *A, scs_float *b,
     Et[i] = MAX(Et[i], SCS(norm_inf)(&(A->x[A->p[i]]), A->p[i + 1] - A->p[i]));
     Et[i] = SAFEDIV_POS(1.0, SQRTF(apply_limit(Et[i])));
   }
-
-  /* calculate s value */
-  *s = MAX(SCS(norm_inf)(c, A->n), SCS(norm_inf)(b, A->m));
-  *s = SAFEDIV_POS(1.0, SQRTF(apply_limit(*s)));
 }
 
-static void compute_l2_mats(ScsMatrix *P, ScsMatrix *A, scs_float *b,
-                            scs_float *c, scs_float *Dt, scs_float *Et,
-                            scs_float *s, ScsConeWork *cone) {
+static void compute_l2_mats(ScsMatrix *P, ScsMatrix *A, scs_float *Dt,
+                            scs_float *Et, ScsConeWork *cone) {
   scs_int i, j, kk;
-  scs_float wrk, norm_c, norm_b;
+  scs_float wrk;
 
   /****************************  D  ****************************/
 
   /* initialize D */
   for (i = 0; i < A->m; ++i) {
-    /* Dt[i] = 0.; */
-    Dt[i] = b[i] * b[i];
+    Dt[i] = 0.;
+    /* Dt[i] = b[i] * b[i]; */
   }
 
   /* calculate row norms */
@@ -207,8 +208,8 @@ static void compute_l2_mats(ScsMatrix *P, ScsMatrix *A, scs_float *b,
 
   /* initialize E */
   for (i = 0; i < A->n; ++i) {
-    /* Et[i] = 0.; */
-    Et[i] = c[i] * c[i];
+    Et[i] = 0.;
+    /* Et[i] = c[i] * c[i]; */
   }
 
   /* TODO: test not using P to determine scaling  */
@@ -234,17 +235,10 @@ static void compute_l2_mats(ScsMatrix *P, ScsMatrix *A, scs_float *b,
     Et[i] += SCS(norm_sq)(&(A->x[A->p[i]]), A->p[i + 1] - A->p[i]);
     Et[i] = SAFEDIV_POS(1.0, SQRTF(apply_limit(SQRTF(Et[i]))));
   }
-
-  /* calculate s value */
-  norm_c = SCS(norm_2)(c, A->n);
-  norm_b = SCS(norm_2)(b, A->m);
-  *s = SQRTF(norm_c * norm_c + norm_b * norm_b);
-  *s = SAFEDIV_POS(1.0, SQRTF(apply_limit(*s)));
 }
 
-static void rescale(ScsMatrix *P, ScsMatrix *A, scs_float *b, scs_float *c,
-                    scs_float *Dt, scs_float *Et, scs_float s, ScsScaling *scal,
-                    ScsConeWork *cone) {
+static void rescale(ScsMatrix *P, ScsMatrix *A, scs_float *Dt, scs_float *Et,
+                    ScsScaling *scal, ScsConeWork *cone) {
   scs_int i, j;
   /* scale the rows of A with D */
   for (i = 0; i < A->n; ++i) {
@@ -271,15 +265,6 @@ static void rescale(ScsMatrix *P, ScsMatrix *A, scs_float *b, scs_float *c,
     }
   }
 
-  /* scale c */
-  for (i = 0; i < A->n; ++i) {
-    c[i] *= Et[i];
-  }
-  /* scale b */
-  for (i = 0; i < A->m; ++i) {
-    b[i] *= Dt[i];
-  }
-
   /* Accumulate scaling */
   for (i = 0; i < A->m; ++i) {
     scal->D[i] *= Dt[i];
@@ -288,53 +273,39 @@ static void rescale(ScsMatrix *P, ScsMatrix *A, scs_float *b, scs_float *c,
     scal->E[i] *= Et[i];
   }
 
-  /* Apply scaling */
-  SCS(scale_array)(c, s, A->n);
-  SCS(scale_array)(b, s, A->m);
-  /* no need to scale P since primal_scale = dual_scale */
+  /* no need to scale P since later primal_scale = dual_scale */
   /*
   if (P) {
     SCS(scale_array)(P->x, primal_scale, P->p[P->n]);
     SCS(scale_array)(P->x, 1.0 / dual_scale, P->p[P->n]);
   }
   */
-
-  /* Accumulate scaling */
-  scal->primal_scale *= s;
-  scal->dual_scale *= s;
 }
 
-/* Will rescale as P -> EPE, A -> DAE, c -> sEc, b -> sDb, in-place.
+/* Will rescale as P -> EPE, A -> DAE in-place.
  * Essentially trying to rescale this matrix:
  *
- * [P  A' c]   with   [E  0  0] on both sides (D, E diagonal)
- * [A  0  b]          [0  D  0]
- * [c' b' 0]          [0  0  s]
+ * [P  A']   with   [E  0 ] on both sides (D, E diagonal)
+ * [A  0 ]          [0  D ]
  *
  * which results in:
  *
- * [ EPE   EA'D  sEc ]
- * [ DAE    0    sDb ]
- * [ sc'E  sb'D   0  ]
+ * [ EPE   EA'D ]
+ * [ DAE    0   ]
  *
- * In other words D rescales the rows of A, b
- *                E rescales the cols of A and rows/cols of P, c'
+ * In other words D rescales the rows of A
+ *                E rescales the cols of A and rows/cols of P
  *
- * will repeatedly set: D^-1 ~ norm of rows of [ A  b ]
+ * will repeatedly set: D^-1 ~ norm of rows of [ A ]
  *
  *                      E^-1 ~ norm of cols of [ P ]
  *                                             [ A ]
- *                                             [ c']
- *
- * `s` is incorporated into dual_scale and primal_scale
  *
  * The main complication is that D has to respect cone boundaries.
  *
  */
-ScsScaling *SCS(normalize_a_p)(ScsMatrix *P, ScsMatrix *A, scs_float *b,
-                               scs_float *c, ScsConeWork *cone) {
+ScsScaling *SCS(normalize_a_p)(ScsMatrix *P, ScsMatrix *A, ScsConeWork *cone) {
   scs_int i;
-  scs_float s;
   ScsScaling *scal = (ScsScaling *)scs_calloc(1, sizeof(ScsScaling));
   scs_float *Dt = (scs_float *)scs_calloc(A->m, sizeof(scs_float));
   scs_float *Et = (scs_float *)scs_calloc(A->n, sizeof(scs_float));
@@ -359,12 +330,12 @@ ScsScaling *SCS(normalize_a_p)(ScsMatrix *P, ScsMatrix *A, scs_float *b,
   scal->primal_scale = 1.;
   scal->dual_scale = 1.;
   for (i = 0; i < NUM_RUIZ_PASSES; ++i) {
-    compute_ruiz_mats(P, A, b, c, Dt, Et, &s, cone);
-    rescale(P, A, b, c, Dt, Et, s, scal, cone);
+    compute_ruiz_mats(P, A, Dt, Et, cone);
+    rescale(P, A, Dt, Et, scal, cone);
   }
   for (i = 0; i < NUM_L2_PASSES; ++i) {
-    compute_l2_mats(P, A, b, c, Dt, Et, &s, cone);
-    rescale(P, A, b, c, Dt, Et, s, scal, cone);
+    compute_l2_mats(P, A, Dt, Et, cone);
+    rescale(P, A, Dt, Et, scal, cone);
   }
   scs_free(Dt);
   scs_free(Et);
@@ -378,14 +349,13 @@ ScsScaling *SCS(normalize_a_p)(ScsMatrix *P, ScsMatrix *A, scs_float *b,
   }
   scs_printf("primal_scale %g\n", scal->primal_scale);
   scs_printf("dual_scale %g\n", scal->dual_scale);
-  scs_printf("norm_b %g\n", SCS(norm_inf)(b, A->m));
-  scs_printf("norm_c %g\n", SCS(norm_inf)(c, A->n));
   scs_printf("norm D %g\n", SCS(norm_inf)(scal->D, A->m));
   scs_printf("norm E %g\n", SCS(norm_inf)(scal->E, A->n));
 #endif
   return scal;
 }
 
+/*
 void SCS(un_normalize_a_p)(ScsMatrix *A, ScsMatrix *P, const ScsScaling *scal) {
   scs_int i, j;
   scs_float *D = scal->D;
@@ -411,6 +381,7 @@ void SCS(un_normalize_a_p)(ScsMatrix *A, ScsMatrix *P, const ScsScaling *scal) {
     }
   }
 }
+*/
 
 void SCS(accum_by_atrans)(const ScsMatrix *A, const scs_float *x,
                           scs_float *y) {

data/vendor/scs/linsys/scs_matrix.h

@@ -13,11 +13,12 @@ extern "C" {
 /* normalizes A matrix, sets scal->E and scal->D diagonal scaling matrices,
  * A -> D*A*E. D and E must be all positive entries, D must satisfy cone
  * boundaries */
-ScsScaling *SCS(normalize_a_p)(ScsMatrix *P, ScsMatrix *A, scs_float *b,
-                               scs_float *c, ScsConeWork *cone);
+ScsScaling *SCS(normalize_a_p)(ScsMatrix *P, ScsMatrix *A, ScsConeWork *cone);
 
 /* unnormalizes A matrix, unnormalizes by w->D and w->E */
-void SCS(un_normalize_a_p)(ScsMatrix *A, ScsMatrix *P, const ScsScaling *scal);
+/* void SCS(un_normalize_a_p)(ScsMatrix *A, ScsMatrix *P, const ScsScaling
+ * *scal);
+ */
 
 /* to free the memory allocated in a ScsMatrix (called on A and P at finish) */
 void SCS(free_scs_matrix)(ScsMatrix *A);

data/vendor/scs/scs.mk

@@ -103,10 +103,6 @@ NOTIMER = 0
 ifneq ($(NOTIMER), 0)
 OPT_FLAGS += -DNOTIMER=$(NOTIMER) # no timing, times reported as nan
 endif
-COPYAMATRIX = 1
-ifneq ($(COPYAMATRIX), 0)
-OPT_FLAGS += -DCOPYAMATRIX=$(COPYAMATRIX) # if normalize, copy A
-endif
 GPU_TRANSPOSE_MAT = 1
 ifneq ($(GPU_TRANSPOSE_MAT), 0)
 OPT_FLAGS += -DGPU_TRANSPOSE_MAT=$(GPU_TRANSPOSE_MAT) # tranpose A mat in GPU memory

data/vendor/scs/src/aa.c

@@ -199,7 +199,6 @@ static void set_m(AaWork *a, aa_int len) {
     }
   }
   TIME_TOC
-  return;
 }
 
 /* initialize accel params, in particular x_prev, f_prev, g_prev */
@@ -278,7 +277,6 @@ static void update_accel_params(const aa_float *x, const aa_float *f, AaWork *a,
   a->norm_g = BLAS(nrm2)(&bdim, a->g, &one);
 
   TIME_TOC
-  return;
 }
 
 /* f = (1-relaxation) * \sum_i a_i x_i + relaxation * \sum_i a_i f_i */
@@ -493,7 +491,6 @@ void aa_finish(AaWork *a) {
     }
     free(a);
   }
-  return;
 }
 
 void aa_reset(AaWork *a) {
@@ -502,7 +499,6 @@ void aa_reset(AaWork *a) {
     printf("AA reset.\n");
   }
   a->iter = 0;
-  return;
 }
 
 #endif

data/vendor/scs/src/cones.c

@@ -35,6 +35,57 @@ void BLAS(scal)(const blas_int *n, const scs_float *sa, scs_float *sx,
 
 #endif
 
+void SCS(free_cone)(ScsCone *k) {
+  if (k) {
+    if (k->bu)
+      scs_free(k->bu);
+    if (k->bl)
+      scs_free(k->bl);
+    if (k->q)
+      scs_free(k->q);
+    if (k->s)
+      scs_free(k->s);
+    if (k->p)
+      scs_free(k->p);
+    scs_free(k);
+  }
+}
+
+void SCS(deep_copy_cone)(ScsCone *dest, const ScsCone *src) {
+  memcpy(dest, src, sizeof(ScsCone));
+  /* copy bu, bl */
+  if (src->bsize > 1) {
+    dest->bu = (scs_float *)scs_calloc(src->bsize - 1, sizeof(scs_float));
+    memcpy(dest->bu, src->bu, (src->bsize - 1) * sizeof(scs_float));
+    dest->bl = (scs_float *)scs_calloc(src->bsize - 1, sizeof(scs_float));
+    memcpy(dest->bl, src->bl, (src->bsize - 1) * sizeof(scs_float));
+  } else {
+    dest->bu = SCS_NULL;
+    dest->bl = SCS_NULL;
+  }
+  /* copy SOC */
+  if (src->qsize > 0) {
+    dest->q = (scs_int *)scs_calloc(src->qsize, sizeof(scs_int));
+    memcpy(dest->q, src->q, src->qsize * sizeof(scs_int));
+  } else {
+    dest->q = SCS_NULL;
+  }
+  /* copy PSD cone */
+  if (src->ssize > 0) {
+    dest->s = (scs_int *)scs_calloc(src->ssize, sizeof(scs_int));
+    memcpy(dest->s, src->s, src->ssize * sizeof(scs_int));
+  } else {
+    dest->s = SCS_NULL;
+  }
+  /* copy power cone */
+  if (src->psize > 0) {
+    dest->p = (scs_float *)scs_calloc(src->psize, sizeof(scs_float));
+    memcpy(dest->p, src->p, src->psize * sizeof(scs_float));
+  } else {
+    dest->p = SCS_NULL;
+  }
+}
+
 /* set the vector of rho y terms, based on scale and cones */
 void SCS(set_r_y)(const ScsConeWork *c, scs_float scale, scs_float *r_y) {
   scs_int i;
@@ -228,12 +279,6 @@ void SCS(finish_cone)(ScsConeWork *c) {
   if (c->s) {
     scs_free(c->s);
   }
-  if (c->bu) {
-    scs_free(c->bu);
-  }
-  if (c->bl) {
-    scs_free(c->bl);
-  }
   if (c) {
     scs_free(c);
   }
@@ -580,18 +625,18 @@ static scs_float pow_calc_fp(scs_float x, scs_float y, scs_float dxdr,
  *       { (t', s') | t' * l' <= s' <= t' u', t >= 0 } = K'
  *  where l' = D l  / d0, u' = D u / d0.
  */
-static void normalize_box_cone(ScsConeWork *c, scs_float *D, scs_int bsize) {
+static void normalize_box_cone(ScsCone *k, scs_float *D, scs_int bsize) {
   scs_int j;
   for (j = 0; j < bsize - 1; j++) {
-    if (c->bu[j] >= MAX_BOX_VAL) {
-      c->bu[j] = INFINITY;
+    if (k->bu[j] >= MAX_BOX_VAL) {
+      k->bu[j] = INFINITY;
     } else {
-      c->bu[j] = D ? D[j + 1] * c->bu[j] / D[0] : c->bu[j];
+      k->bu[j] = D ? D[j + 1] * k->bu[j] / D[0] : k->bu[j];
     }
-    if (c->bl[j] <= -MAX_BOX_VAL) {
-      c->bl[j] = -INFINITY;
+    if (k->bl[j] <= -MAX_BOX_VAL) {
+      k->bl[j] = -INFINITY;
     } else {
-      c->bl[j] = D ? D[j + 1] * c->bl[j] / D[0] : c->bl[j];
+      k->bl[j] = D ? D[j + 1] * k->bl[j] / D[0] : k->bl[j];
     }
   }
 }
@@ -740,7 +785,6 @@ static scs_int proj_cone(scs_float *x, const ScsCone *k, ScsConeWork *c,
   scs_int i, status;
   scs_int count = 0;
   scs_float *r_box = SCS_NULL;
-  scs_float *bu, *bl;
 
   if (k->z) { /* doesn't use r_y */
     /* project onto primal zero / dual free cone */
@@ -761,9 +805,7 @@ static scs_int proj_cone(scs_float *x, const ScsCone *k, ScsConeWork *c,
       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 = proj_box_cone(&(x[count]), k->bl, k->bu, k->bsize,
                                         c->box_t_warm_start, r_box);
     count += k->bsize; /* since b = (t,s), len(s) = bsize - 1 */
   }
@@ -864,7 +906,7 @@ static scs_int proj_cone(scs_float *x, const ScsCone *k, ScsConeWork *c,
   return 0;
 }
 
-ScsConeWork *SCS(init_cone)(const ScsCone *k, scs_int m) {
+ScsConeWork *SCS(init_cone)(ScsCone *k, scs_int m) {
   ScsConeWork *c = (ScsConeWork *)scs_calloc(1, sizeof(ScsConeWork));
   c->k = k;
   c->m = m;
@@ -880,16 +922,12 @@ ScsConeWork *SCS(init_cone)(const ScsCone *k, scs_int m) {
   return c;
 }
 
-void scale_box_cone(const ScsCone *k, ScsConeWork *c, ScsScaling *scal) {
+void scale_box_cone(ScsCone *k, ScsConeWork *c, ScsScaling *scal) {
   if (k->bsize && k->bu && k->bl) {
     c->box_t_warm_start = 1.;
     if (scal) {
-      c->bu = (scs_float *)scs_calloc(k->bsize - 1, sizeof(scs_float));
-      c->bl = (scs_float *)scs_calloc(k->bsize - 1, sizeof(scs_float));
-      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->D[k->z + k->l]), k->bsize);
+      normalize_box_cone(k, &(scal->D[k->z + k->l]), k->bsize);
     }
   }
 }
@@ -909,7 +947,7 @@ void scale_box_cone(const ScsCone *k, ScsConeWork *c, ScsScaling *scal) {
 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;
+  ScsCone *k = c->k;
 
   if (!c->scaled_cones) {
     scale_box_cone(k, c, scal);

data/vendor/scs/src/normalize.c

@@ -3,6 +3,55 @@
 #include "linalg.h"
 #include "scs.h"
 
+/* copied from linsys/scs_matrix.c */
+#define MIN_NORMALIZATION_FACTOR (1e-4)
+#define MAX_NORMALIZATION_FACTOR (1e4)
+
+/* Given D, E in scaling normalize b, c and compute primal / dual scales.
+ *
+ * Recall that	the normalization routine is performing:
+ *
+ * [P  A' c]   with   [E  0  0] on both sides (D, E diagonal)
+ * [A  0  b]          [0  D  0]
+ * [c' b' 0]          [0  0  s]
+ *
+ * which results in:
+ *
+ * [ EPE   EA'D  sEc ]
+ * [ DAE    0    sDb ]
+ * [ sc'E  sb'D   0  ]
+ *
+ * `s` is incorporated into dual_scale and primal_scale
+ *
+ */
+void SCS(normalize_b_c)(ScsScaling *scal, scs_float *b, scs_float *c) {
+  scs_int i;
+  scs_float sigma;
+
+  /* scale c */
+  for (i = 0; i < scal->n; ++i) {
+    c[i] *= scal->E[i];
+  }
+  /* scale b */
+  for (i = 0; i < scal->m; ++i) {
+    b[i] *= scal->D[i];
+  }
+
+  /* calculate primal and dual scales */
+  sigma = MAX(SCS(norm_inf)(c, scal->n), SCS(norm_inf)(b, scal->m));
+  sigma = sigma < MIN_NORMALIZATION_FACTOR ? 1.0 : sigma;
+  sigma = sigma > MAX_NORMALIZATION_FACTOR ? MAX_NORMALIZATION_FACTOR : sigma;
+  sigma = SAFEDIV_POS(1.0, sigma);
+
+  /* Scale b, c */
+  SCS(scale_array)(c, sigma, scal->n);
+  SCS(scale_array)(b, sigma, scal->m);
+
+  /* We assume that primal_scale = dual_scale, otherwise need to refactorize */
+  scal->primal_scale = sigma;
+  scal->dual_scale = sigma;
+}
+
 /* needed for normalizing the warm-start */
 void SCS(normalize_sol)(ScsScaling *scal, ScsSolution *sol) {
   scs_int i;

data/vendor/scs/src/rw.c

@@ -33,21 +33,29 @@ 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_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);
+  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);
-  k->q = (scs_int *)scs_calloc(k->qsize, sizeof(scs_int));
-  fread(k->q, sizeof(scs_int), k->qsize, fin);
+  if (k->qsize) {
+    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_int *)scs_calloc(k->ssize, sizeof(scs_int));
-  fread(k->s, sizeof(scs_int), k->ssize, fin);
+  if (k->ssize) {
+    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_float *)scs_calloc(k->psize, sizeof(scs_float));
-  fread(k->p, sizeof(scs_float), k->psize, fin);
+  if (k->psize) {
+    k->p = (scs_float *)scs_calloc(k->psize, sizeof(scs_float));
+    fread(k->p, sizeof(scs_float), k->psize, fin);
+  }
   return k;
 }
 
@@ -208,9 +216,9 @@ scs_int SCS(read_data)(const char *filename, ScsData **d, ScsCone **k,
   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) {
+void SCS(log_data_to_csv)(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;
   ScsSolution *sol = w->xys_orig;
@@ -222,7 +230,7 @@ void SCS(log_data_to_csv)(const ScsData *d, const ScsCone *k,
                stgs->log_csv_filename);
     return;
   }
-  scs_int l = w->m + w->n + 1;
+  scs_int l = w->d->m + w->d->n + 1;
   if (iter == 0) {
     /* need to end in comma so that csv parsing is correct */
     fprintf(fout, "iter,"
@@ -286,22 +294,22 @@ 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));
-  fprintf(fout, "%.16e,", SCS(norm_2)(r->px_aty_ctau, w->n));
+  fprintf(fout, "%.16e,", SCS(norm_inf)(sol->x, w->d->n));
+  fprintf(fout, "%.16e,", SCS(norm_inf)(sol->y, w->d->m));
+  fprintf(fout, "%.16e,", SCS(norm_inf)(sol->s, w->d->m));
+  fprintf(fout, "%.16e,", SCS(norm_2)(sol->x, w->d->n));
+  fprintf(fout, "%.16e,", SCS(norm_2)(sol->y, w->d->m));
+  fprintf(fout, "%.16e,", SCS(norm_2)(sol->s, w->d->m));
+  fprintf(fout, "%.16e,", SCS(norm_inf)(sol_n->x, w->d->n));
+  fprintf(fout, "%.16e,", SCS(norm_inf)(sol_n->y, w->d->m));
+  fprintf(fout, "%.16e,", SCS(norm_inf)(sol_n->s, w->d->m));
+  fprintf(fout, "%.16e,", SCS(norm_2)(sol_n->x, w->d->n));
+  fprintf(fout, "%.16e,", SCS(norm_2)(sol_n->y, w->d->m));
+  fprintf(fout, "%.16e,", SCS(norm_2)(sol_n->s, w->d->m));
+  fprintf(fout, "%.16e,", SCS(norm_inf)(r->ax_s_btau, w->d->m));
+  fprintf(fout, "%.16e,", SCS(norm_inf)(r->px_aty_ctau, w->d->n));
+  fprintf(fout, "%.16e,", SCS(norm_2)(r->ax_s_btau, w->d->m));
+  fprintf(fout, "%.16e,", SCS(norm_2)(r->px_aty_ctau, w->d->n));
   fprintf(fout, "%.16e,", r->res_infeas);
   fprintf(fout, "%.16e,", r->res_unbdd_a);
   fprintf(fout, "%.16e,", r->res_unbdd_p);
@@ -312,10 +320,10 @@ void SCS(log_data_to_csv)(const ScsData *d, const ScsCone *k,
   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,", SCS(norm_inf)(r_n->ax_s_btau, w->d->m));
+  fprintf(fout, "%.16e,", SCS(norm_inf)(r_n->px_aty_ctau, w->d->n));
+  fprintf(fout, "%.16e,", SCS(norm_2)(r_n->ax_s_btau, w->d->m));
+  fprintf(fout, "%.16e,", SCS(norm_2)(r_n->px_aty_ctau, w->d->n));
   fprintf(fout, "%.16e,", r_n->res_infeas);
   fprintf(fout, "%.16e,", r_n->res_unbdd_a);
   fprintf(fout, "%.16e,", r_n->res_unbdd_p);
@@ -323,12 +331,12 @@ 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_inf)(r->ax, 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,", 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);
   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));