scs 0.5.3 → 0.5.4

data/vendor/scs/src/cones.c

@@ -3,38 +3,37 @@
 #include "scs.h"
 #include "scs_blas.h" /* contains BLAS(X) macros and type info */
 #include "util.h"
+
+/*
+ * Cross-platform Complex Type Handling
+ * MSVC uses struct layout; GCC/Clang uses C99 _Complex
+ */
 #if defined(_MSC_VER)
-  /* MSVC: no C99 <complex.h> */
+typedef struct {
+  double real, imag;
+} scs_blas_cdouble;
+typedef struct {
+  float real, imag;
+} scs_blas_cfloat;
+#ifndef SFLOAT
+#define SCS_BLAS_COMPLEX_TYPE scs_blas_cdouble
+#define SCS_BLAS_COMPLEX_CAST(x) ((scs_blas_cdouble *)(x))
 #else
-  #include <complex.h>
+#define SCS_BLAS_COMPLEX_TYPE scs_blas_cfloat
+#define SCS_BLAS_COMPLEX_CAST(x) ((scs_blas_cfloat *)(x))
 #endif
-
-// We need these definitions here to avoid including complex.h in scs_types.h.
-// Including complex.h in scs_types.h causes issues when building with C++
-// compilers. Reach out to Daniel Cederberg if you have any questions about the
-// following 7 lines of code.
-#if defined(_MSC_VER)
-  /* MSVC C: use POD layout compatible with interleaved BLAS complex */
-  typedef struct { double real, imag; } scs_blas_cdouble;
-  typedef struct { float  real, imag; } scs_blas_cfloat;
-  #ifndef SFLOAT
-    #define SCS_BLAS_COMPLEX_TYPE scs_blas_cdouble
-    #define SCS_BLAS_COMPLEX_CAST(x) ((scs_blas_cdouble *)(x))
-  #else
-    #define SCS_BLAS_COMPLEX_TYPE scs_blas_cfloat
-    #define SCS_BLAS_COMPLEX_CAST(x) ((scs_blas_cfloat *)(x))
-  #endif
 #else
-  /* GCC/Clang: keep using C99 _Complex */
-  #ifndef SFLOAT
-    #define SCS_BLAS_COMPLEX_CAST(x) ((double _Complex *)(x))
-    #define SCS_BLAS_COMPLEX_TYPE double _Complex
-  #else
-    #define SCS_BLAS_COMPLEX_CAST(x) ((float _Complex *)(x))
-    #define SCS_BLAS_COMPLEX_TYPE float _Complex
-  #endif
+#include <complex.h>
+#ifndef SFLOAT
+#define SCS_BLAS_COMPLEX_CAST(x) ((double _Complex *)(x))
+#define SCS_BLAS_COMPLEX_TYPE double _Complex
+#else
+#define SCS_BLAS_COMPLEX_CAST(x) ((float _Complex *)(x))
+#define SCS_BLAS_COMPLEX_TYPE float _Complex
+#endif
 #endif
 
+/* Constants */
 #define BOX_CONE_MAX_ITERS (25)
 #define POW_CONE_TOL (1e-9)
 #define POW_CONE_MAX_ITERS (20)
@@ -48,9 +47,14 @@
 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);
+/* LAPACK / BLAS Function Prototypes */
+void BLAS(syevr)(const char *jobz, const char *range, const char *uplo,
+                 blas_int *n, scs_float *a, blas_int *lda, scs_float *vl,
+                 scs_float *vu, blas_int *il, blas_int *iu, scs_float *abstol,
+                 blas_int *m, scs_float *w, scs_float *z, blas_int *ldz,
+                 blas_int *isuppz, scs_float *work, blas_int *lwork,
+                 blas_int *iwork, blas_int *liwork, blas_int *info);
+
 void BLASC(heevr)(const char *jobz, const char *range, const char *uplo,
                   blas_int *n, SCS_BLAS_COMPLEX_TYPE *a, blas_int *lda,
                   scs_float *vl, scs_float *vu, blas_int *il, blas_int *iu,
@@ -83,7 +87,7 @@ void BLAS(gesvd)(const char *jobu, const char *jobvt, const blas_int *m,
                  const blas_int *ldvt, scs_float *work, const blas_int *lwork,
                  blas_int *info);
 
-// Forward declare spectral matrix cone projections
+/* Forward declare spectral matrix cone projections */
 scs_int SCS(proj_logdet_cone)(scs_float *tvX, const scs_int n, ScsConeWork *c,
                               scs_int offset, bool *warmstart);
 scs_int SCS(proj_nuclear_cone)(scs_float *tX, scs_int m, scs_int n,
@@ -96,13 +100,15 @@ scs_int SCS(proj_sum_largest_evals)(scs_float *tX, scs_int n, scs_int k,
 #ifdef __cplusplus
 }
 #endif
-#endif
+#endif /* USE_LAPACK */
 
-/* Forward declare exponential cone projection routine.
- * Implemented in exp_cone.c.
- */
+/* Forward declare exponential cone projection (exp_cone.c) */
 scs_float SCS(proj_pd_exp_cone)(scs_float *v0, scs_int primal);
 
+/*
+ * Memory Management
+ */
+
 void SCS(free_cone)(ScsCone *k) {
   if (k) {
     if (k->bu)
@@ -137,74 +143,83 @@ void SCS(free_cone)(ScsCone *k) {
 
 void SCS(deep_copy_cone)(ScsCone *dest, const ScsCone *src) {
   memcpy(dest, src, sizeof(ScsCone));
-  /* copy bu, bl */
+
+  /* Box cone */
   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->bu, src->bu, (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 */
+
+  /* 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 */
+
+  /* PSD */
   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 complex PSD cone */
+
+  /* Complex PSD */
   if (src->cssize > 0) {
     dest->cs = (scs_int *)scs_calloc(src->cssize, sizeof(scs_int));
     memcpy(dest->cs, src->cs, src->cssize * sizeof(scs_int));
   } else {
     dest->cs = SCS_NULL;
   }
-  /* copy power cone */
+
+  /* Power */
   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;
   }
+
 #ifdef USE_SPECTRAL_CONES
-  /* copy logdet cone */
+  /* Logdet */
   if (src->dsize > 0) {
     dest->d = (scs_int *)scs_calloc(src->dsize, sizeof(scs_int));
     memcpy(dest->d, src->d, src->dsize * sizeof(scs_int));
   } else {
     dest->d = SCS_NULL;
   }
-  /* copy nuclear norm cone*/
+
+  /* Nuclear */
   if (src->nucsize > 0) {
     dest->nuc_m = (scs_int *)scs_calloc(src->nucsize, sizeof(scs_int));
-    memcpy(dest->nuc_m, src->nuc_m, src->nucsize * sizeof(scs_int));
     dest->nuc_n = (scs_int *)scs_calloc(src->nucsize, sizeof(scs_int));
+    memcpy(dest->nuc_m, src->nuc_m, src->nucsize * sizeof(scs_int));
     memcpy(dest->nuc_n, src->nuc_n, src->nucsize * sizeof(scs_int));
   } else {
     dest->nuc_m = SCS_NULL;
     dest->nuc_n = SCS_NULL;
   }
-  /* copy ell1-norm cone */
+
+  /* Ell1 */
   if (src->ell1_size > 0) {
     dest->ell1 = (scs_int *)scs_calloc(src->ell1_size, sizeof(scs_int));
     memcpy(dest->ell1, src->ell1, src->ell1_size * sizeof(scs_int));
   } else {
     dest->ell1 = SCS_NULL;
   }
-  /* copy sum-of-largest eigenvalues cone */
+
+  /* Sum Largest Eigenvalues */
   if (src->sl_size > 0) {
     dest->sl_n = (scs_int *)scs_calloc(src->sl_size, sizeof(scs_int));
-    memcpy(dest->sl_n, src->sl_n, src->sl_size * sizeof(scs_int));
     dest->sl_k = (scs_int *)scs_calloc(src->sl_size, sizeof(scs_int));
+    memcpy(dest->sl_n, src->sl_n, src->sl_size * sizeof(scs_int));
     memcpy(dest->sl_k, src->sl_k, src->sl_size * sizeof(scs_int));
   } else {
     dest->sl_n = SCS_NULL;
@@ -213,7 +228,17 @@ void SCS(deep_copy_cone)(ScsCone *dest, const ScsCone *src) {
 #endif
 }
 
-/* set the vector of rho y terms, based on scale and cones */
+/*
+ * Helper Functions
+ */
+
+static inline scs_int get_sd_cone_size(scs_int s) {
+  return (s * (s + 1)) / 2;
+}
+static inline scs_int get_csd_cone_size(scs_int cs) {
+  return cs * cs;
+}
+
 void SCS(set_r_y)(const ScsConeWork *c, scs_float scale, scs_float *r_y) {
   scs_int i;
   /* z cone */
@@ -224,14 +249,13 @@ void SCS(set_r_y)(const ScsConeWork *c, scs_float scale, scs_float *r_y) {
      */
     r_y[i] = 1.0 / (1000. * scale);
   }
-
-  /* others */
+  /* Remaining cones */
   for (i = c->k->z; i < c->m; ++i) {
     r_y[i] = 1.0 / scale;
   }
 }
 
-/* the function f aggregates the entries within each cone */
+/* 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;
@@ -247,140 +271,77 @@ void SCS(enforce_cone_boundaries)(const ScsConeWork *c, scs_float *vec,
   }
 }
 
-static inline scs_int get_sd_cone_size(scs_int s) {
-  return (s * (s + 1)) / 2;
-}
-
-static inline scs_int get_csd_cone_size(scs_int cs) {
-  return cs * cs;
-}
-
 /*
- * boundaries will contain array of indices of rows of A corresponding to
+ * Boundaries will contain array of indices of rows of A corresponding to
  * cone boundaries, boundaries[0] is starting index for cones of size strictly
  * larger than 1, boundaries malloc-ed here so should be freed.
  */
 void set_cone_boundaries(const ScsCone *k, ScsConeWork *c) {
-  scs_int i, s_cone_sz, cs_cone_sz, count = 0;
+  scs_int i, count = 0;
 #ifdef USE_SPECTRAL_CONES
-  scs_int cone_boundaries_len = 1 + k->qsize + k->ssize + k->cssize + k->ed +
-                                k->ep + k->psize + k->dsize + k->nucsize +
-                                k->ell1_size + k->sl_size;
+  scs_int total_cones = k->qsize + k->ssize + k->cssize + k->ed + k->ep +
+                        k->psize + k->dsize + k->nucsize + k->ell1_size +
+                        k->sl_size;
 #else
-  scs_int cone_boundaries_len =
-      1 + k->qsize + k->ssize + k->cssize + k->ed + k->ep + k->psize;
+  scs_int total_cones =
+      k->qsize + k->ssize + k->cssize + k->ed + k->ep + k->psize;
 #endif
-  scs_int *b = (scs_int *)scs_calloc(cone_boundaries_len, sizeof(scs_int));
-  /* cones that can be scaled independently */
-  b[count] = k->z + k->l + k->bsize;
-  count += 1; /* started at 0 now move to first entry */
-  for (i = 0; i < k->qsize; ++i) {
-    b[count + i] = k->q[i];
-  }
-  count += k->qsize;
-  /* semidefinite cones */
-  for (i = 0; i < k->ssize; ++i) {
-    s_cone_sz = get_sd_cone_size(k->s[i]);
-    b[count + i] = s_cone_sz;
-  }
-  count += k->ssize; /* size here not ssize * (ssize + 1) / 2 */
-  for (i = 0; i < k->cssize; ++i) {
-    cs_cone_sz = get_csd_cone_size(k->cs[i]);
-    b[count + i] = cs_cone_sz;
-  }
-  count += k->cssize;
-  /* exp cones */
-  for (i = 0; i < k->ep + k->ed; ++i) {
-    b[count + i] = 3;
-  }
-  count += k->ep + k->ed;
-  /* power cones */
-  for (i = 0; i < k->psize; ++i) {
-    b[count + i] = 3;
-  }
-  count += k->psize;
+  scs_int *b = (scs_int *)scs_calloc(total_cones + 1, sizeof(scs_int));
+
+  /* Cones that can be scaled independently */
+  b[count++] = k->z + k->l + k->bsize;
+  for (i = 0; i < k->qsize; ++i)
+    b[count++] = k->q[i];
+  for (i = 0; i < k->ssize; ++i)
+    b[count++] = get_sd_cone_size(k->s[i]);
+  for (i = 0; i < k->cssize; ++i)
+    b[count++] = get_csd_cone_size(k->cs[i]);
+  for (i = 0; i < k->ep + k->ed; ++i)
+    b[count++] = 3;
+  for (i = 0; i < k->psize; ++i)
+    b[count++] = 3;
+
 #ifdef USE_SPECTRAL_CONES
-  /* logdet cones */
-  for (i = 0; i < k->dsize; ++i) {
-    b[count + i] = get_sd_cone_size(k->d[i]) + 2;
-  }
-  count += k->dsize;
-  /* nuclear norm cones */
-  for (i = 0; i < k->nucsize; ++i) {
-    b[count + i] = k->nuc_m[i] * k->nuc_n[i] + 1;
-  }
-  count += k->nucsize;
-  /* ell1-norm cones */
-  for (i = 0; i < k->ell1_size; ++i) {
-    b[count + i] = k->ell1[i] + 1;
-  }
-  count += k->ell1_size;
-  /* sum-of-largest eigenvalues cones */
-  for (i = 0; i < k->sl_size; ++i) {
-    b[count + i] = get_sd_cone_size(k->sl_n[i]) + 1;
-  }
-  count += k->sl_size;
+  for (i = 0; i < k->dsize; ++i)
+    b[count++] = get_sd_cone_size(k->d[i]) + 2;
+  for (i = 0; i < k->nucsize; ++i)
+    b[count++] = k->nuc_m[i] * k->nuc_n[i] + 1;
+  for (i = 0; i < k->ell1_size; ++i)
+    b[count++] = k->ell1[i] + 1;
+  for (i = 0; i < k->sl_size; ++i)
+    b[count++] = get_sd_cone_size(k->sl_n[i]) + 1;
 #endif
-  /* other cones */
+
   c->cone_boundaries = b;
-  c->cone_boundaries_len = cone_boundaries_len;
+  c->cone_boundaries_len = total_cones + 1;
 }
 
 static scs_int get_full_cone_dims(const ScsCone *k) {
-  scs_int i, c = k->z + k->l + k->bsize;
-  if (k->qsize) {
-    for (i = 0; i < k->qsize; ++i) {
-      c += k->q[i];
-    }
-  }
-  if (k->ssize) {
-    for (i = 0; i < k->ssize; ++i) {
-      c += get_sd_cone_size(k->s[i]);
-    }
-  }
-  if (k->cssize) {
-    for (i = 0; i < k->cssize; ++i) {
-      c += get_csd_cone_size(k->cs[i]);
-    }
-  }
-  if (k->ed) {
-    c += 3 * k->ed;
-  }
-  if (k->ep) {
-    c += 3 * k->ep;
-  }
-  if (k->psize) {
-    c += 3 * k->psize;
-  }
+  scs_int i, dims = k->z + k->l + k->bsize;
+  for (i = 0; i < k->qsize; ++i)
+    dims += k->q[i];
+  for (i = 0; i < k->ssize; ++i)
+    dims += get_sd_cone_size(k->s[i]);
+  for (i = 0; i < k->cssize; ++i)
+    dims += get_csd_cone_size(k->cs[i]);
+  dims += 3 * (k->ed + k->ep + k->psize);
 #ifdef USE_SPECTRAL_CONES
-  if (k->dsize) {
-    for (i = 0; i < k->dsize; ++i) {
-      c += get_sd_cone_size(k->d[i]) + 2;
-    }
-  }
-  if (k->nucsize) {
-    for (i = 0; i < k->nucsize; ++i) {
-      c += k->nuc_m[i] * k->nuc_n[i] + 1;
-    }
-  }
-  if (k->ell1_size) {
-    for (i = 0; i < k->ell1_size; ++i) {
-      c += k->ell1[i] + 1;
-    }
-  }
-  if (k->sl_size) {
-    for (i = 0; i < k->sl_size; ++i) {
-      c += get_sd_cone_size(k->sl_n[i]) + 1;
-    }
-  }
+  for (i = 0; i < k->dsize; ++i)
+    dims += get_sd_cone_size(k->d[i]) + 2;
+  for (i = 0; i < k->nucsize; ++i)
+    dims += k->nuc_m[i] * k->nuc_n[i] + 1;
+  for (i = 0; i < k->ell1_size; ++i)
+    dims += k->ell1[i] + 1;
+  for (i = 0; i < k->sl_size; ++i)
+    dims += get_sd_cone_size(k->sl_n[i]) + 1;
 #endif
-  return c;
+  return dims;
 }
 
 scs_int SCS(validate_cones)(const ScsData *d, const ScsCone *k) {
   scs_int i;
   if (get_full_cone_dims(k) != d->m) {
-    scs_printf("cone dimensions %li not equal to num rows in A = m = %li\n",
+    scs_printf("Error: Cone dims %li != rows in A %li\n",
                (long)get_full_cone_dims(k), (long)d->m);
     return -1;
   }
@@ -510,124 +471,98 @@ scs_int SCS(validate_cones)(const ScsData *d, const ScsCone *k) {
 }
 
 void SCS(finish_cone)(ScsConeWork *c) {
+  if (!c)
+    return;
 #ifdef USE_LAPACK
-  if (c->Xs) {
+  if (c->Xs)
     scs_free(c->Xs);
-  }
-  if (c->cXs) {
+  if (c->cXs)
     scs_free(c->cXs);
-  }
-  if (c->Z) {
+  if (c->Z)
     scs_free(c->Z);
-  }
-  if (c->cZ) {
+  if (c->cZ)
     scs_free(c->cZ);
-  }
-  if (c->e) {
+  if (c->e)
     scs_free(c->e);
-  }
-  if (c->isuppz) {
+  if (c->isuppz)
     scs_free(c->isuppz);
-  }
-  if (c->work) {
+  if (c->work)
     scs_free(c->work);
-  }
-  if (c->iwork) {
+  if (c->iwork)
     scs_free(c->iwork);
-  }
-  if (c->cwork) {
+  if (c->cwork)
     scs_free(c->cwork);
-  }
-  if (c->rwork) {
-    scs_free(c->rwork);
-  }
+  /* c->rwork is aliased to c->work in setup, no free needed */
 #endif
-  if (c->cone_boundaries) {
+  if (c->cone_boundaries)
     scs_free(c->cone_boundaries);
-  }
-  if (c->s) {
+  if (c->s)
     scs_free(c->s);
-  }
+
 #ifdef USE_SPECTRAL_CONES
-  if (c->work_logdet) {
+  if (c->work_logdet)
     scs_free(c->work_logdet);
-  }
-  if (c->saved_log_projs) {
+  if (c->saved_log_projs)
     scs_free(c->saved_log_projs);
-  }
-  if (c->s_nuc) {
+  if (c->s_nuc)
     scs_free(c->s_nuc);
-  }
-  if (c->u_nuc) {
+  if (c->u_nuc)
     scs_free(c->u_nuc);
-  }
-  if (c->vt_nuc) {
+  if (c->vt_nuc)
     scs_free(c->vt_nuc);
-  }
-  if (c->work_nuc) {
+  if (c->work_nuc)
     scs_free(c->work_nuc);
-  }
-  if (c->work_sum_of_largest) {
+  if (c->work_sum_of_largest)
     scs_free(c->work_sum_of_largest);
-  }
-  if (c->log_cone_warmstarts) {
+  if (c->log_cone_warmstarts)
     scs_free(c->log_cone_warmstarts);
-  }
-  if (c->work_ell1) {
+  if (c->work_ell1)
     scs_free(c->work_ell1);
-  }
-  if (c->work_ell1_proj) {
+  if (c->work_ell1_proj)
     scs_free(c->work_ell1_proj);
-  }
 #endif
-  if (c) {
-    scs_free(c);
-  }
+  scs_free(c);
 }
 
 char *SCS(get_cone_header)(const ScsCone *k) {
-  char *tmp = (char *)scs_malloc(512); /* sizeof(char) = 1 */
-  scs_int i, soc_vars, sd_vars, csd_vars;
+  char *tmp = (char *)scs_malloc(512);
+  scs_int i, count;
+
   sprintf(tmp, "cones: ");
-  if (k->z) {
+  if (k->z)
     sprintf(tmp + strlen(tmp), "\t  z: primal zero / dual free vars: %li\n",
             (long)k->z);
-  }
-  if (k->l) {
+  if (k->l)
     sprintf(tmp + strlen(tmp), "\t  l: linear vars: %li\n", (long)k->l);
-  }
-  if (k->bsize) {
-    sprintf(tmp + strlen(tmp), "\t  b: box cone vars: %li\n", (long)(k->bsize));
-  }
-  soc_vars = 0;
-  if (k->qsize && k->q) {
-    for (i = 0; i < k->qsize; i++) {
-      soc_vars += k->q[i];
-    }
+  if (k->bsize)
+    sprintf(tmp + strlen(tmp), "\t  b: box cone vars: %li\n", (long)k->bsize);
+
+  if (k->qsize) {
+    count = 0;
+    for (i = 0; i < k->qsize; ++i)
+      count += k->q[i];
     sprintf(tmp + strlen(tmp), "\t  q: soc vars: %li, qsize: %li\n",
-            (long)soc_vars, (long)k->qsize);
+            (long)count, (long)k->qsize);
   }
-  sd_vars = 0;
-  if (k->ssize && k->s) {
-    for (i = 0; i < k->ssize; i++) {
-      sd_vars += get_sd_cone_size(k->s[i]);
-    }
+  if (k->ssize) {
+    count = 0;
+    for (i = 0; i < k->ssize; ++i)
+      count += get_sd_cone_size(k->s[i]);
     sprintf(tmp + strlen(tmp), "\t  s: psd vars: %li, ssize: %li\n",
-            (long)sd_vars, (long)k->ssize);
+            (long)count, (long)k->ssize);
   }
-  csd_vars = 0;
-  if (k->cssize && k->cs) {
-    for (i = 0; i < k->cssize; i++) {
-      csd_vars += get_csd_cone_size(k->cs[i]);
-    }
+  if (k->cssize) {
+    count = 0;
+    for (i = 0; i < k->cssize; ++i)
+      count += get_csd_cone_size(k->cs[i]);
     sprintf(tmp + strlen(tmp), "\t  cs: complex psd vars: %li, cssize: %li\n",
-            (long)csd_vars, (long)k->cssize);
+            (long)count, (long)k->cssize);
   }
   if (k->ep || k->ed) {
     sprintf(tmp + strlen(tmp), "\t  e: exp vars: %li, dual exp vars: %li\n",
             (long)(3 * k->ep), (long)(3 * k->ed));
   }
-  if (k->psize && k->p) {
+  if (k->psize) {
     sprintf(tmp + strlen(tmp), "\t  p: primal + dual power vars: %li\n",
             (long)(3 * k->psize));
   }
@@ -667,190 +602,215 @@ char *SCS(get_cone_header)(const ScsCone *k) {
             (long)sl_vars, (long)k->sl_size);
   }
 #endif
-
   return tmp;
 }
 
-static scs_int set_up_sd_cone_work_space(ScsConeWork *c, const ScsCone *k) {
+/*
+ * Workspace Setup
+ * Consolidated setup for Real PSD, Complex PSD, and Spectral cones.
+ */
+static scs_int set_up_cone_work_spaces(ScsConeWork *c, const ScsCone *k) {
   scs_int i;
 #ifdef USE_LAPACK
+  /* Max dim for eigenvalues (e) and integer work (isuppz) */
   blas_int n_max = 1;
-  blas_int neg_one = -1;
-  blas_int info = 0;
+  blas_int n_max_real = 1; /* Max dim for Real PSD matrix (Xs) */
+  blas_int n_max_csd = 1;  /* Max dim for Complex PSD matrix (cXs) */
+
+  /* LAPACK Query Variables */
+  blas_int neg_one = -1, info = 0, m = 0;
+  blas_int d_i = 0;
+  scs_float d_f = 0.0, abstol = -1.0;
   scs_float wkopt = 0.0;
-#if VERBOSITY > 0
-#define _STR_EXPAND(tok) #tok
-#define _STR(tok) _STR_EXPAND(tok)
-  scs_printf("BLAS(func) = '%s'\n", _STR(BLAS(func)));
-#endif
+  blas_int iwkopt = 0;
+  scs_complex_float lcwork_opt = {0.0};
+  scs_float lrwork_opt = 0.0;
+  blas_int liwork_opt_c = 0;
 
-  // ----------------------------------------------------------------------
-  //   compute max dimension needed for eigenvalue decomposition workspace
-  //   (all cones appearing in the next section of code require eigenvalue
-  //    decompositions)
-  // ----------------------------------------------------------------------
+  /* Max workspace sizes across all cone types */
+  blas_int lwork_max = 0;
+  blas_int liwork_max = 0;
+
+  /* Calculate Dimensions */
   for (i = 0; i < k->ssize; ++i) {
-    if (k->s[i] > n_max) {
-      n_max = (blas_int)k->s[i];
-    }
+    n_max = MAX(n_max, (blas_int)k->s[i]);
+    n_max_real = MAX(n_max_real, (blas_int)k->s[i]);
+  }
+  for (i = 0; i < k->cssize; ++i) {
+    n_max = MAX(n_max, (blas_int)k->cs[i]);
+    n_max_csd = MAX(n_max_csd, (blas_int)k->cs[i]);
   }
 
 #ifdef USE_SPECTRAL_CONES
   blas_int n_max_logdet = 1;
   blas_int n_logdet_total = 0;
   blas_int n_max_sl = 1;
-  c->log_cone_warmstarts = (bool *)scs_calloc(k->dsize, sizeof(bool));
 
-  for (i = 0; i < k->sl_size; ++i) {
-    if (k->sl_n[i] > n_max_sl) {
-      n_max_sl = (blas_int)k->sl_n[i];
-    }
-  }
+  c->log_cone_warmstarts = (bool *)scs_calloc(k->dsize, sizeof(bool));
 
+  /* Spectral Dimensions */
+  for (i = 0; i < k->sl_size; ++i)
+    n_max_sl = MAX(n_max_sl, (blas_int)k->sl_n[i]);
   for (i = 0; i < k->dsize; ++i) {
     n_logdet_total += (blas_int)k->d[i];
-    if (k->d[i] > n_max_logdet) {
-      n_max_logdet = (blas_int)k->d[i];
-    }
+    n_max_logdet = MAX(n_max_logdet, (blas_int)k->d[i]);
   }
 
-  // --------------------------------------------------------------------------
-  //         allocate workspace for logdeterminant cones
-  // --------------------------------------------------------------------------
+  /* Logdet Allocation */
   if (k->dsize > 0) {
     c->work_logdet =
         (scs_float *)scs_calloc(22 * n_max_logdet + 122, sizeof(scs_float));
     c->saved_log_projs = (scs_float *)scs_calloc(2 * k->dsize + n_logdet_total,
                                                  sizeof(scs_float));
-
-    if (!c->work_logdet || !c->saved_log_projs) {
+    if (!c->work_logdet || !c->saved_log_projs)
       return -1;
-    }
   }
-
-  // ---------------------------------------------------------------
-  //        allocate workspace for sum-of-largest-eigenvalues cone
-  // ---------------------------------------------------------------
+  /* Sum Largest Allocation */
   if (k->sl_size > 0) {
     c->work_sum_of_largest =
         (scs_float *)scs_calloc(n_max_sl * n_max_sl, sizeof(scs_float));
-    if (!c->work_sum_of_largest) {
+    if (!c->work_sum_of_largest)
       return -1;
-    }
   }
+
+  /* Update Max Real Dims based on Spectral needs */
   n_max = MAX(n_max, n_max_logdet);
   n_max = MAX(n_max, n_max_sl);
+  n_max_real = MAX(n_max_real, n_max_logdet);
+  n_max_real = MAX(n_max_real, n_max_sl);
 #endif
-  // -----------------------------------------------------------------
-  //         allocate eigenvector decomposition workspace
-  // -----------------------------------------------------------------
-  c->Xs = (scs_float *)scs_calloc(n_max * n_max, sizeof(scs_float));
-  c->Z = (scs_float *)scs_calloc(n_max * n_max, sizeof(scs_float));
+
+  /* Allocate standard eigenvalue buffers
+   * 'e' stores eigenvalues, 'isuppz' supports them. Shared by Real/Complex.
+   */
   c->e = (scs_float *)scs_calloc(n_max, sizeof(scs_float));
+  c->isuppz = (blas_int *)scs_calloc(MAX(2, 2 * n_max), sizeof(blas_int));
+  if (!c->e || !c->isuppz)
+    return -1;
 
-  /* workspace query */
-  BLAS(syev)("Vectors", "Lower", &n_max, c->Xs, &n_max, SCS_NULL, &wkopt,
-             &neg_one, &info);
+  /* 1. Real PSD Workspace Query (syevr) */
+  if (k->ssize > 0
+#ifdef USE_SPECTRAL_CONES
+      || k->dsize > 0 || k->sl_size > 0
+#endif
+  ) {
+    c->Xs = (scs_float *)scs_calloc(n_max_real * n_max_real, sizeof(scs_float));
+    c->Z = (scs_float *)scs_calloc(n_max_real * n_max_real, sizeof(scs_float));
+    if (!c->Xs || !c->Z)
+      return -1;
 
-  if (info != 0) {
-    scs_printf("FATAL: syev workspace query failure, info = %li\n", (long)info);
-    return -1;
+    BLAS(syevr)("V", "A", "L", &n_max_real, c->Xs, &n_max_real, &d_f, &d_f,
+                &d_i, &d_i, &abstol, &m, c->e, c->Z, &n_max_real, c->isuppz,
+                &wkopt, &neg_one, &iwkopt, &neg_one, &info);
+
+    if (info != 0) {
+      scs_printf("FATAL: syevr workspace query failure, info = %li\n",
+                 (long)info);
+      return -1;
+    }
+    lwork_max = MAX(lwork_max, (blas_int)(wkopt + 1));
+    liwork_max = MAX(liwork_max, iwkopt);
   }
 
-  c->lwork = (blas_int)(wkopt + 1); /* +1 for int casting safety */
-  c->work = (scs_float *)scs_calloc(c->lwork, sizeof(scs_float));
+  /* 2. Complex PSD Workspace Query (heevr) */
+  if (k->cssize > 0) {
+    c->cXs = (scs_complex_float *)scs_calloc(n_max_csd * n_max_csd,
+                                             sizeof(scs_complex_float));
+    c->cZ = (scs_complex_float *)scs_calloc(n_max_csd * n_max_csd,
+                                            sizeof(scs_complex_float));
+    if (!c->cXs || !c->cZ)
+      return -1;
 
-  if (!c->Xs || !c->Z || !c->e || !c->work) {
-    return -1;
+    BLASC(heevr)("V", "A", "L", &n_max_csd, SCS_BLAS_COMPLEX_CAST(c->cXs),
+                 &n_max_csd, &d_f, &d_f, &d_i, &d_i, &abstol, &m, c->e,
+                 SCS_BLAS_COMPLEX_CAST(c->cZ), &n_max_csd, c->isuppz,
+                 SCS_BLAS_COMPLEX_CAST(&lcwork_opt), &neg_one, &lrwork_opt,
+                 &neg_one, &liwork_opt_c, &neg_one, &info);
+
+    if (info != 0) {
+      scs_printf("FATAL: heevr workspace query failure, info = %li\n",
+                 (long)info);
+      return -1;
+    }
+
+    c->lcwork = (blas_int)(lcwork_opt[0]);
+    c->cwork =
+        (scs_complex_float *)scs_calloc(c->lcwork, sizeof(scs_complex_float));
+    if (!c->cwork)
+      return -1;
+
+    /* heevr uses a real 'rwork' array. We alias this to the shared real 'work'
+     * array */
+    lwork_max = MAX(lwork_max, (blas_int)lrwork_opt);
+    liwork_max = MAX(liwork_max, liwork_opt_c);
   }
 
 #ifdef USE_SPECTRAL_CONES
-  // ------------------------------------------------------------------
-  //              allocate memory for nuclear norm cone
-  // ------------------------------------------------------------------
+  /* 3. Nuclear Norm Workspace (gesvd) */
   if (k->nucsize > 0) {
-    blas_int m_max_nuc = 1;
-    blas_int n_max_nuc = 1;
+    blas_int m_max = 1, n_max_n = 1;
     for (i = 0; i < k->nucsize; ++i) {
-      if (k->nuc_m[i] > m_max_nuc) {
-        m_max_nuc = k->nuc_m[i];
-      }
-      if (k->nuc_n[i] > n_max_nuc) {
-        n_max_nuc = k->nuc_n[i];
-      }
+      m_max = MAX(m_max, (blas_int)k->nuc_m[i]);
+      n_max_n = MAX(n_max_n, (blas_int)k->nuc_n[i]);
     }
 
-    c->s_nuc = (scs_float *)scs_calloc(n_max_nuc, sizeof(scs_float));
-    c->u_nuc =
-        (scs_float *)scs_calloc(m_max_nuc * n_max_nuc, sizeof(scs_float));
-    c->vt_nuc =
-        (scs_float *)scs_calloc(n_max_nuc * n_max_nuc, sizeof(scs_float));
-
-    if (!c->s_nuc || !c->u_nuc || !c->vt_nuc) {
+    c->s_nuc = (scs_float *)scs_calloc(n_max_n, sizeof(scs_float));
+    c->u_nuc = (scs_float *)scs_calloc(m_max * n_max_n, sizeof(scs_float));
+    c->vt_nuc = (scs_float *)scs_calloc(n_max_n * n_max_n, sizeof(scs_float));
+    if (!c->s_nuc || !c->u_nuc || !c->vt_nuc)
       return -1;
-    }
-
-    // workspace query
-    BLAS(gesvd)("S", "A", &m_max_nuc, &n_max_nuc, c->u_nuc, &m_max_nuc,
-                c->s_nuc, c->u_nuc, &m_max_nuc, c->vt_nuc, &n_max_nuc, &wkopt,
-                &neg_one, &info);
 
-    c->lwork_nuc = (blas_int)(wkopt + 1); /* +1 for int casting safety */
-    c->work_nuc = (scs_float *)scs_calloc(c->lwork_nuc, sizeof(scs_float));
+    BLAS(gesvd)("S", "A", &m_max, &n_max_n, c->u_nuc, &m_max, c->s_nuc,
+                c->u_nuc, &m_max, c->vt_nuc, &n_max_n, &wkopt, &neg_one, &info);
 
-    if (!c->lwork_nuc || !c->work_nuc) {
+    if (info != 0)
       return -1;
-    }
 
-    if (info != 0) {
-      scs_printf("FATAL: gesvd workspace query failure, info = %li\n",
-                 (long)info);
+    /* We allocate work_nuc separately to avoid aliasing risks during SVD
+     * perations */
+    c->lwork_nuc = (blas_int)(wkopt + 1);
+    c->work_nuc = (scs_float *)scs_calloc(c->lwork_nuc, sizeof(scs_float));
+    if (!c->work_nuc)
       return -1;
-    }
   }
 #endif
 
-  return 0;
-#else
-  for (i = 0; i < k->ssize; i++) {
-    if (k->s[i] > 1) {
-      scs_printf(
-          "FATAL: Cannot solve SDPs without linked blas+lapack libraries\n");
-      scs_printf(
-          "Install blas+lapack and re-compile SCS with blas+lapack library "
-          "locations\n");
+  /* Final Consolidated Allocation
+   * c->work aliases 'work' for syevr and 'rwork' for heevr
+   */
+  if (lwork_max > 0) {
+    c->lwork = lwork_max;
+    c->work = (scs_float *)scs_calloc(c->lwork, sizeof(scs_float));
+    if (!c->work)
       return -1;
-    }
   }
-#ifdef USE_SPECTRAL_CONES
-  bool has_spectral_cones = false;
-  for (i = 0; i < k->dsize; i++) {
-    if (k->d[i] > 1) {
-      has_spectral_cones = true;
-      break;
-    }
+  if (liwork_max > 0) {
+    c->liwork = liwork_max;
+    c->iwork = (blas_int *)scs_calloc(c->liwork, sizeof(blas_int));
+    if (!c->iwork)
+      return -1;
   }
 
-  for (i = 0; i < k->nucsize; i++) {
-    if (k->nuc_m[i] > 1 || k->nuc_n[i] > 1) {
-      has_spectral_cones = true;
-      break;
+  return 0;
+#else
+  /* Non-LAPACK fallback check */
+  if (k->ssize > 0 || k->cssize > 0) {
+    for (i = 0; i < k->ssize; i++) {
+      if (k->s[i] > 1) {
+        scs_printf("FATAL: SDP/Complex SDP requires BLAS/LAPACK.\n");
+        return -1;
+      }
     }
-  }
-
-  for (i = 0; i < k->sl_size; i++) {
-    if (k->sl_n[i] > 1) {
-      has_spectral_cones = true;
-      break;
+    for (i = 0; i < k->cssize; i++) {
+      if (k->cs[i] > 1) {
+        scs_printf("FATAL: SDP/Complex SDP requires BLAS/LAPACK.\n");
+        return -1;
+      }
     }
   }
-
-  if (has_spectral_cones) {
-    scs_printf("FATAL: Cannot use spectral cones without linked blas+lapack "
-               "libraries\n");
-    scs_printf(
-        "Install blas+lapack and re-compile SCS with blas+lapack library "
-        "locations\n");
+#ifdef USE_SPECTRAL_CONES
+  if (k->dsize > 0 || k->nucsize > 0 || k->sl_size > 0) {
+    scs_printf("FATAL: Spectral cones require BLAS/LAPACK.\n");
     return -1;
   }
 #endif
@@ -858,347 +818,201 @@ static scs_int set_up_sd_cone_work_space(ScsConeWork *c, const ScsCone *k) {
 #endif
 }
 
-/* size of X is get_sd_cone_size(n) */
-static scs_int proj_semi_definite_cone(scs_float *X, const scs_int n,
-                                       ScsConeWork *c) {
-/* project onto the positive semi-definite cone */
-#ifdef USE_LAPACK
-  SCS(timer) _timer;
-  scs_int i, first_idx;
-  blas_int nb = (blas_int)n;
-  blas_int ncols_z;
-  blas_int nb_plus_one = (blas_int)(n + 1);
-  blas_int one_int = 1;
-  scs_float zero = 0., one = 1.;
-  scs_float sqrt2 = SQRTF(2.0);
-  scs_float sqrt2_inv = 1.0 / sqrt2;
-  scs_float *Xs = c->Xs;
-  scs_float *Z = c->Z;
-  scs_float *e = c->e;
-  scs_float *work = c->work;
-  blas_int lwork = c->lwork;
-  blas_int info = 0;
-  scs_float sq_eig_pos;
-
+#ifdef USE_SPECTRAL_CONES
+static scs_int set_up_ell1_cone_work_space(ScsConeWork *c, const ScsCone *k) {
+  scs_int i, n_max = 0;
+  if (k->ell1_size > 0) {
+    for (i = 0; i < k->ell1_size; ++i)
+      n_max = MAX(k->ell1[i], n_max);
+    c->work_ell1 = (Value_index *)scs_calloc(n_max, sizeof(Value_index));
+    c->work_ell1_proj = (scs_float *)scs_calloc(n_max + 1, sizeof(scs_float));
+    if (!c->work_ell1 || !c->work_ell1_proj)
+      return -1;
+  }
+  return 0;
+}
 #endif
 
-  if (n == 0) {
+/*
+ * Projection: Real Semi-Definite Cone
+ */
+static scs_int proj_semi_definite_cone(scs_float *X, const scs_int n,
+                                       ScsConeWork *c) {
+  if (n == 0)
     return 0;
-  }
   if (n == 1) {
     X[0] = MAX(X[0], 0.);
     return 0;
   }
 
 #ifdef USE_LAPACK
-
-  /* copy lower triangular matrix into full matrix */
+  scs_int i;
+  blas_int nb = (blas_int)n;
+  blas_int nb_p1 = (blas_int)(n + 1);
+  blas_int info = 0, one_int = 1, ncols_z = 0;
+  scs_float zero = 0., one = 1., sqrt2 = SQRTF(2.0), sqrt2_inv = 1.0 / sqrt2;
+  scs_float abstol = -1.0, d_f = 0.0, sq_eig;
+  blas_int m = 0, d_i = 0;
+  scs_int first_idx = -1;
+
+  /* Copy lower triangular part to full matrix buffer Xs */
   for (i = 0; i < n; ++i) {
-    memcpy(&(Xs[i * (n + 1)]), &(X[i * n - ((i - 1) * i) / 2]),
+    memcpy(&(c->Xs[i * (n + 1)]), &(X[i * n - ((i - 1) * i) / 2]),
            (n - i) * sizeof(scs_float));
   }
-  /*
-     rescale so projection works, and matrix norm preserved
-     see http://www.seas.ucla.edu/~vandenbe/publications/mlbook.pdf pg 3
-   */
-  /* scale diags by sqrt(2) */
-  BLAS(scal)(&nb, &sqrt2, Xs, &nb_plus_one); /* not n_squared */
-
-  /* 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", (int)info);
-    if (info < 0) {
-      return info;
-    }
-  }
 
-  SCS(tic)(&_timer);
+  /* Scale diagonals by sqrt(2) */
+  BLAS(scal)(&nb, &sqrt2, c->Xs, &nb_p1);
 
-  first_idx = -1;
-  /* e is eigvals in ascending order, find first entry > 0 */
+  /* Solve Eigenproblem: Xs = Z * diag(e) * Z' */
+  BLAS(syevr)("V", "A", "L", &nb, c->Xs, &nb, &d_f, &d_f, &d_i, &d_i, &abstol,
+              &m, c->e, c->Z, &nb, c->isuppz, c->work, &c->lwork, c->iwork,
+              &c->liwork, &info);
+  if (info != 0)
+    return (int)info;
+
+  /* Filter negative eigenvalues and scale eigenvectors */
+  /* Note: e is in ascending order */
   for (i = 0; i < n; ++i) {
-    if (e[i] > 0) {
-      first_idx = i;
-      break;
+    if (c->e[i] > 0) {
+      if (first_idx == -1) {
+        first_idx = i;
+      }
+      sq_eig = SQRTF(c->e[i]);
+      BLAS(scal)(&nb, &sq_eig, &c->Z[i * n], &one_int);
     }
   }
-
   if (first_idx == -1) {
     /* there are no positive eigenvalues, set X to 0 and return */
     memset(X, 0, sizeof(scs_float) * get_sd_cone_size(n));
     return 0;
   }
-
-  /* Z is matrix of eigenvectors with positive eigenvalues */
-  memcpy(Z, &Xs[first_idx * n], sizeof(scs_float) * n * (n - first_idx));
-
-  /* scale Z by sqrt(eig) */
-  for (i = first_idx; i < n; ++i) {
-    sq_eig_pos = SQRTF(e[i]);
-    BLAS(scal)(&nb, &sq_eig_pos, &Z[(i - first_idx) * n], &one_int);
-  }
-
-  /* Xs = Z Z' = V E V' */
+  /* Reconstruct Xs = Z * Z' */
   ncols_z = (blas_int)(n - first_idx);
-  BLAS(syrk)("Lower", "NoTrans", &nb, &ncols_z, &one, Z, &nb, &zero, Xs, &nb);
+  BLAS(syrk)("Lower", "NoTrans", &nb, &ncols_z, &one, &c->Z[first_idx * n], &nb,
+             &zero, c->Xs, &nb);
 
-  /* undo rescaling: scale diags by 1/sqrt(2) */
-  BLAS(scal)(&nb, &sqrt2_inv, Xs, &nb_plus_one); /* not n_squared */
+  /* Rescale diagonals by 1/sqrt(2) */
+  BLAS(scal)(&nb, &sqrt2_inv, c->Xs, &nb_p1);
 
-  /* extract just lower triangular matrix */
+  /* Extract lower triangular matrix back to X */
   for (i = 0; i < n; ++i) {
-    memcpy(&(X[i * n - ((i - 1) * i) / 2]), &(Xs[i * (n + 1)]),
+    memcpy(&(X[i * n - ((i - 1) * i) / 2]), &(c->Xs[i * (n + 1)]),
            (n - i) * sizeof(scs_float));
   }
   return 0;
-
 #else
-  scs_printf("FAILURE: solving SDP but no blas/lapack libraries were found!\n");
-  scs_printf("SCS will return nonsense!\n");
-  SCS(scale_array)(X, NAN, get_sd_cone_size(n));
   return -1;
 #endif
 }
 
-static scs_int set_up_csd_cone_work_space(ScsConeWork *c, const ScsCone *k) {
-  scs_int i;
-#ifdef USE_LAPACK
-  blas_int n_max = 1;
-  blas_int neg_one = -1;
-  blas_int info = 0;
-  scs_float abstol = -1.0;
-  blas_int m = 0;
-  scs_complex_float lcwork = {0.0};
-  scs_float lrwork = 0.0;
-  blas_int liwork = 0;
-#if VERBOSITY > 0
-#define _STR_EXPAND(tok) #tok
-#define _STR(tok) _STR_EXPAND(tok)
-  scs_printf("BLAS(func) = '%s'\n", _STR(BLASC(func)));
-#endif
-  /* eigenvector decomp workspace */
-  for (i = 0; i < k->cssize; ++i) {
-    if (k->cs[i] > n_max) {
-      n_max = (blas_int)k->cs[i];
-    }
-  }
-  c->cXs =
-      (scs_complex_float *)scs_calloc(n_max * n_max, sizeof(scs_complex_float));
-  c->cZ =
-      (scs_complex_float *)scs_calloc(n_max * n_max, sizeof(scs_complex_float));
-  c->e = (scs_float *)scs_calloc(n_max, sizeof(scs_float));
-  c->isuppz = (blas_int *)scs_calloc(MAX(2, 2 * n_max), sizeof(blas_int));
-
-  /* workspace query */
-  BLASC(heevr)
-  ("V", "A", "L", &n_max, SCS_BLAS_COMPLEX_CAST(c->cXs), &n_max, SCS_NULL,
-   SCS_NULL, SCS_NULL, SCS_NULL, &abstol, &m, c->e,
-   SCS_BLAS_COMPLEX_CAST(c->cZ), &n_max, c->isuppz,
-   SCS_BLAS_COMPLEX_CAST(&lcwork), &neg_one, &lrwork, &neg_one, &liwork,
-   &neg_one, &info);
-
-  if (info != 0) {
-    scs_printf("FATAL: heev workspace query failure, info = %li\n", (long)info);
-    return -1;
-  }
-  c->lcwork = (blas_int)(lcwork[0]);
-  c->lrwork = (blas_int)(lrwork);
-  c->liwork = liwork;
-  c->cwork =
-      (scs_complex_float *)scs_calloc(c->lcwork, sizeof(scs_complex_float));
-  c->rwork = (scs_float *)scs_calloc(c->lrwork, sizeof(scs_float));
-  c->iwork = (blas_int *)scs_calloc(c->liwork, sizeof(blas_int));
-
-  if (!c->cXs || !c->cZ || !c->e || !c->isuppz || !c->cwork || !c->rwork ||
-      !c->iwork) {
-    return -1;
-  }
-  return 0;
-#else
-  for (i = 0; i < k->cssize; i++) {
-    if (k->cs[i] > 1) {
-      scs_printf(
-          "FATAL: Cannot solve SDPs without linked blas+lapack libraries\n");
-      scs_printf(
-          "Install blas+lapack and re-compile SCS with blas+lapack library "
-          "locations\n");
-      return -1;
-    }
-  }
-  return 0;
-#endif
-}
-
-/* size of X is get_csd_cone_size(n) */
+/*
+ * Projection: Complex Semi-Definite Cone
+ */
 static scs_int proj_complex_semi_definite_cone(scs_float *X, const scs_int n,
                                                ScsConeWork *c) {
-/* project onto the positive semi-definite cone */
-#ifdef USE_LAPACK
-  scs_int i, first_idx;
-  blas_int nb = (blas_int)n;
-  blas_int ncols_z;
-  blas_int nb_plus_one = (blas_int)(n + 1);
-  blas_int one_int = 1;
-  scs_float zero = 0., one = 1.;
-  scs_complex_float csqrt2 = {0.0};
-  csqrt2[0] = SQRTF(2.0);
-  scs_complex_float csqrt2_inv = {0.0};
-  csqrt2_inv[0] = 1.0 / csqrt2[0];
-  ;
-  scs_complex_float *cXs = c->cXs;
-  scs_complex_float *cZ = c->cZ;
-  scs_float *e = c->e;
-  scs_float abstol = -1.0;
-  blas_int m = 0;
-  blas_int info = 0;
-  scs_complex_float csq_eig_pos = {0.0};
-
-#endif
-
-  if (n == 0) {
+  if (n == 0)
     return 0;
-  }
   if (n == 1) {
     X[0] = MAX(X[0], 0.);
     return 0;
   }
 
 #ifdef USE_LAPACK
+  scs_int i;
+  blas_int nb = (blas_int)n;
+  blas_int nb_p1 = (blas_int)(n + 1);
+  blas_int info = 0, one_int = 1, d_i = 0, ncols_z = 0;
+  scs_float zero = 0., one = 1., abstol = -1.0, d_f = 0.0;
+  blas_int m = 0;
+  scs_int first_idx = -1;
+
+  /* Complex constants */
+  scs_complex_float csqrt2 = {0.0}, csqrt2_inv = {0.0}, csq_eig = {0.0};
+  csqrt2[0] = SQRTF(2.0);
+  csqrt2_inv[0] = 1.0 / csqrt2[0];
 
-  /* copy lower triangular matrix into full matrix */
+  /* Unpack X (real array) into cXs (complex matrix) */
   for (i = 0; i < n - 1; ++i) {
-    cXs[i * (n + 1)][0] = X[i * (2 * n - i)];
-    cXs[i * (n + 1)][1] = 0.0;
-    memcpy(&(cXs[i * (n + 1) + 1]), &(X[i * (2 * n - i) + 1]),
+    c->cXs[i * (n + 1)][0] = X[i * (2 * n - i)]; /* Diagonal (Real) */
+    c->cXs[i * (n + 1)][1] = 0.0;
+    memcpy(&(c->cXs[i * (n + 1) + 1]), &(X[i * (2 * n - i) + 1]),
            2 * (n - i - 1) * sizeof(scs_float));
   }
-  cXs[n * n - 1][0] = X[n * n - 1];
-  cXs[n * n - 1][1] = 0.0;
-  /*
-     rescale so projection works, and matrix norm preserved
-     see http://www.seas.ucla.edu/~vandenbe/publications/mlbook.pdf pg 3
-   */
-  /* scale diags by sqrt(2) */
-  BLASC(scal)
-  (&nb, SCS_BLAS_COMPLEX_CAST(&csqrt2), SCS_BLAS_COMPLEX_CAST(cXs),
-   &nb_plus_one); /* not n_squared */
-
-  /* Solve eigenproblem, reuse workspaces */
-  BLASC(heevr)
-  ("V", "A", "L", &nb, SCS_BLAS_COMPLEX_CAST(cXs), &nb, SCS_NULL, SCS_NULL,
-   SCS_NULL, SCS_NULL, &abstol, &m, e, SCS_BLAS_COMPLEX_CAST(cZ), &nb,
-   c->isuppz, SCS_BLAS_COMPLEX_CAST(c->cwork), &c->lcwork, c->rwork, &c->lrwork,
-   c->iwork, &c->liwork, &info);
-
-  if (info != 0) {
-    scs_printf("WARN: LAPACK heev error, info = %i\n", (int)info);
-    if (info < 0) {
-      return info;
-    }
-  }
+  c->cXs[n * n - 1][0] = X[n * n - 1]; /* Last element */
+  c->cXs[n * n - 1][1] = 0.0;
 
-  first_idx = -1;
-  /* e is eigvals in ascending order, find first entry > 0 */
+  /* Scale diagonals by sqrt*/
+  BLASC(scal)(&nb, SCS_BLAS_COMPLEX_CAST(&csqrt2),
+              SCS_BLAS_COMPLEX_CAST(c->cXs), &nb_p1);
+
+  /* Solve Eigenproblem. Note: c->work acts as rwork here. */
+  BLASC(heevr)("V", "A", "L", &nb, SCS_BLAS_COMPLEX_CAST(c->cXs), &nb, &d_f,
+               &d_f, &d_i, &d_i, &abstol, &m, c->e,
+               SCS_BLAS_COMPLEX_CAST(c->cZ), &nb, c->isuppz,
+               SCS_BLAS_COMPLEX_CAST(c->cwork), &c->lcwork, c->work, &c->lwork,
+               c->iwork, &c->liwork, &info);
+  if (info != 0)
+    return (int)info;
+
+  /* Reconstruct */
   for (i = 0; i < n; ++i) {
-    if (e[i] > 0) {
-      first_idx = i;
-      break;
+    if (c->e[i] > 0) {
+      if (first_idx == -1) {
+        first_idx = i;
+      }
+      csq_eig[0] = SQRTF(c->e[i]);
+      BLASC(scal)(&nb, SCS_BLAS_COMPLEX_CAST(&csq_eig),
+                  SCS_BLAS_COMPLEX_CAST(&c->cZ[i * n]), &one_int);
     }
   }
-
   if (first_idx == -1) {
     /* there are no positive eigenvalues, set X to 0 and return */
     memset(X, 0, sizeof(scs_float) * get_csd_cone_size(n));
     return 0;
   }
 
-  /* cZ is matrix of all eigenvectors */
-  /* scale cZ by sqrt(eig) */
-  for (i = first_idx; i < n; ++i) {
-    csq_eig_pos[0] = SQRTF(e[i]);
-    BLASC(scal)
-    (&nb, SCS_BLAS_COMPLEX_CAST(&csq_eig_pos),
-     SCS_BLAS_COMPLEX_CAST(&cZ[i * n]), &one_int);
-  }
-
-  /* Xs = cZ cZ' = V E V' */
+  /* cXs = cZ * cZ' */
   ncols_z = (blas_int)(n - first_idx);
-  BLASC(herk)
-  ("Lower", "NoTrans", &nb, &ncols_z, &one,
-   SCS_BLAS_COMPLEX_CAST(&cZ[first_idx * n]), &nb, &zero,
-   SCS_BLAS_COMPLEX_CAST(cXs), &nb);
+  BLASC(herk)("Lower", "NoTrans", &nb, &ncols_z, &one,
+              SCS_BLAS_COMPLEX_CAST(&c->cZ[first_idx * n]), &nb, &zero,
+              SCS_BLAS_COMPLEX_CAST(c->cXs), &nb);
 
-  /* undo rescaling: scale diags by 1/sqrt(2) */
-  BLASC(scal)
-  (&nb, SCS_BLAS_COMPLEX_CAST(&csqrt2_inv), SCS_BLAS_COMPLEX_CAST(cXs),
-   &nb_plus_one); /* not n_squared */
+  /* Rescale diagonals */
+  BLASC(scal)(&nb, SCS_BLAS_COMPLEX_CAST(&csqrt2_inv),
+              SCS_BLAS_COMPLEX_CAST(c->cXs), &nb_p1);
 
-  /* extract just lower triangular matrix */
+  /* Repack into X */
   for (i = 0; i < n - 1; ++i) {
-    X[i * (2 * n - i)] = cXs[i * (n + 1)][0];
-    memcpy(&(X[i * (2 * n - i) + 1]), &(cXs[i * (n + 1) + 1]),
+    X[i * (2 * n - i)] = c->cXs[i * (n + 1)][0];
+    memcpy(&(X[i * (2 * n - i) + 1]), &(c->cXs[i * (n + 1) + 1]),
            2 * (n - i - 1) * sizeof(scs_float));
   }
-  X[n * n - 1] = cXs[n * n - 1][0];
+  X[n * n - 1] = c->cXs[n * n - 1][0];
   return 0;
-
 #else
-  scs_printf("FAILURE: solving SDP but no blas/lapack libraries were found!\n");
-  scs_printf("SCS will return nonsense!\n");
-  SCS(scale_array)(X, NAN, get_csd_cone_size(n));
   return -1;
 #endif
 }
 
-static scs_float pow_calc_x(scs_float r, scs_float xh, scs_float rh,
-                            scs_float a) {
-  scs_float x = 0.5 * (xh + SQRTF(xh * xh + 4 * a * (rh - r) * r));
-  return MAX(x, 1e-12);
-}
-
-static scs_float pow_calcdxdr(scs_float x, scs_float xh, scs_float rh,
-                              scs_float r, scs_float a) {
-  return a * (rh - 2 * r) / (2 * x - xh);
-}
-
-static scs_float pow_calc_f(scs_float x, scs_float y, scs_float r,
-                            scs_float a) {
-  return POWF(x, a) * POWF(y, (1 - a)) - r;
-}
-
-static scs_float pow_calc_fp(scs_float x, scs_float y, scs_float dxdr,
-                             scs_float dydr, scs_float a) {
-  return POWF(x, a) * POWF(y, (1 - a)) * (a * dxdr / x + (1 - a) * dydr / y) -
-         1;
-}
-
 /*
- * Routine to scale the limits of the box cone by the scaling diagonal mat D > 0
- *
- *  want (t, s) \in K <==> (t', s') \in K'
- *
- *  (t', s') = (d0 * t, D s) (overloading D to mean D[1:])
- *    (up to scalar scaling factor which we can ignore due to conic property)
- *
- *   K = { (t, s) | t * l <= s <= t * u, t >= 0 } =>
- *       { (t, s) | d0 * t * D l / d0 <= D s <= d0 * t D u / d0, t >= 0 } =>
- *       { (t', s') | t' * l' <= s' <= t' u', t >= 0 } = K'
- *  where l' = D l  / d0, u' = D u / d0.
+ * Projection: Box Cone
  */
 static void normalize_box_cone(ScsCone *k, scs_float *D, scs_int bsize) {
   scs_int j;
+  scs_float factor;
   for (j = 0; j < bsize - 1; j++) {
-    if (k->bu[j] >= MAX_BOX_VAL) {
+    factor = D ? D[j + 1] / D[0] : 1.0;
+
+    if (k->bu[j] >= MAX_BOX_VAL)
       k->bu[j] = INFINITY;
-    } else {
-      k->bu[j] = D ? D[j + 1] * k->bu[j] / D[0] : k->bu[j];
-    }
-    if (k->bl[j] <= -MAX_BOX_VAL) {
+    else
+      k->bu[j] *= factor;
+
+    if (k->bl[j] <= -MAX_BOX_VAL)
       k->bl[j] = -INFINITY;
-    } else {
-      k->bl[j] = D ? D[j + 1] * k->bl[j] / D[0] : k->bl[j];
-    }
+    else
+      k->bl[j] *= factor;
   }
 }
 
@@ -1207,106 +1021,113 @@ static void normalize_box_cone(ScsCone *k, scs_float *D, scs_int bsize) {
 */
 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 *r_box) {
-  scs_float *x, gt, ht, t_prev, t = t_warm_start;
-  scs_float rho_t = 1, *rho = SCS_NULL, r;
+                               scs_float t_wm, scs_float *r_box) {
+  scs_float *x = &(tx[1]);
+  scs_float gt, ht, t = t_wm, t_prev, r;
+  scs_float rho_t = 1.0;
+  scs_float *rho = SCS_NULL;
   scs_int iter, j;
 
-  if (bsize == 1) { /* special case */
+  if (bsize == 1) {
     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 */
+  /* Newton's method for t */
   for (iter = 0; iter < BOX_CONE_MAX_ITERS; iter++) {
     t_prev = t;
-    gt = rho_t * (t - tx[0]); /* gradient */
-    ht = rho_t;               /* hessian */
+    gt = rho_t * (t - tx[0]);
+    ht = rho_t;
+
     for (j = 0; j < bsize - 1; j++) {
-      r = rho ? 1.0 / rho[j] : 1.;
+      r = rho ? 1.0 / rho[j] : 1.0;
       if (x[j] > t * bu[j]) {
-        gt += r * (t * bu[j] - x[j]) * bu[j]; /* gradient */
-        ht += r * bu[j] * bu[j];              /* hessian */
+        gt += r * (t * bu[j] - x[j]) * bu[j];
+        ht += r * bu[j] * bu[j];
       } else if (x[j] < t * bl[j]) {
-        gt += r * (t * bl[j] - x[j]) * bl[j]; /* gradient */
-        ht += r * bl[j] * bl[j];              /* hessian */
+        gt += r * (t * bl[j] - x[j]) * bl[j];
+        ht += r * bl[j] * bl[j];
       }
     }
-    t = MAX(t - gt / MAX(ht, 1e-8), 0.); /* newton step */
-#if VERBOSITY > 3
-    scs_printf("iter %i, t_new %1.3e, t_prev %1.3e, gt %1.3e, ht %1.3e\n", iter,
-               t, t_prev, gt, ht);
-    scs_printf("ABS(gt / (ht + 1e-6)) %.4e, ABS(t - t_prev) %.4e\n",
-               ABS(gt / (ht + 1e-6)), ABS(t - t_prev));
-#endif
-    /* TODO: sometimes this check can fail (ie, declare convergence before it
+
+    t = MAX(t - gt / MAX(ht, 1e-8), 0.0);
+
+    /*
+     * TODO: sometimes this check can fail (ie, declare convergence before it
      * should) if ht is very large, which can happen with some pathological
      * problems.
      */
     if (ABS(gt / MAX(ht, 1e-6)) < 1e-12 * MAX(t, 1.) ||
-        ABS(t - t_prev) < 1e-11 * MAX(t, 1.)) {
+        ABS(t - t_prev) < 1e-11 * MAX(t, 1.))
       break;
-    }
-  }
-  if (iter == BOX_CONE_MAX_ITERS) {
-    scs_printf("warning: box cone proj hit maximum %i iters\n", (int)iter);
   }
+
+  /* Apply calculated t to x */
   for (j = 0; j < bsize - 1; j++) {
-    if (x[j] > t * bu[j]) {
+    if (x[j] > t * bu[j])
       x[j] = t * bu[j];
-    } else if (x[j] < t * bl[j]) {
+    else if (x[j] < t * bl[j])
       x[j] = t * bl[j];
-    }
-    /* x[j] unchanged otherwise */
   }
   tx[0] = t;
-
-#if VERBOSITY > 3
-  scs_printf("box cone iters %i\n", (int)iter + 1);
-#endif
   return t;
 }
 
-/* project onto SOC of size q*/
+/*
+ * Projection: Second Order Cone
+ */
 static void proj_soc(scs_float *x, scs_int q) {
-  if (q == 0) {
+  if (q <= 0)
     return;
-  }
   if (q == 1) {
     x[0] = MAX(x[0], 0.);
     return;
   }
+
   scs_float v1 = x[0];
   scs_float s = SCS(norm_2)(&(x[1]), q - 1);
   scs_float alpha = (s + v1) / 2.0;
 
-  if (s <= v1) {
-    return;
-  } else if (s <= -v1) {
-    memset(&(x[0]), 0, q * sizeof(scs_float));
-  } else {
+  if (s <= v1)
+    return;       /* Inside cone */
+  if (s <= -v1) { /* Below dual cone */
+    memset(x, 0, q * sizeof(scs_float));
+  } else { /* Projection */
     x[0] = alpha;
     SCS(scale_array)(&(x[1]), alpha / s, q - 1);
   }
 }
 
+/*
+ * Projection: Power Cone
+ */
+static scs_float pow_calc_x(scs_float r, scs_float xh, scs_float rh,
+                            scs_float a) {
+  scs_float x = 0.5 * (xh + SQRTF(xh * xh + 4 * a * (rh - r) * r));
+  return MAX(x, 1e-12);
+}
+
+static scs_float pow_calc_fp(scs_float x, scs_float y, scs_float dxdr,
+                             scs_float dydr, scs_float a) {
+  return POWF(x, a) * POWF(y, (1 - a)) * (a * dxdr / x + (1 - a) * dydr / y) -
+         1;
+}
+
 static void proj_power_cone(scs_float *v, scs_float a) {
   scs_float xh = v[0], yh = v[1], rh = ABS(v[2]);
   scs_float x = 0.0, y = 0.0, r;
   scs_int i;
-  /* v in K_a */
+
+  /* Check v membership in K_a */
   if (xh >= 0 && yh >= 0 &&
-      POW_CONE_TOL + POWF(xh, a) * POWF(yh, (1 - a)) >= rh) {
+      POW_CONE_TOL + POWF(xh, a) * POWF(yh, (1 - a)) >= rh)
     return;
-  }
 
-  /* -v in K_a^* */
+  /* Check -v membership in Polar K_a^* */
   if (xh <= 0 && yh <= 0 &&
       POW_CONE_TOL + POWF(-xh, a) * POWF(-yh, 1 - a) >=
           rh * POWF(a, a) * POWF(1 - a, 1 - a)) {
@@ -1320,13 +1141,12 @@ static void proj_power_cone(scs_float *v, scs_float a) {
     x = pow_calc_x(r, xh, rh, a);
     y = pow_calc_x(r, yh, rh, 1 - a);
 
-    f = pow_calc_f(x, y, r, a);
-    if (ABS(f) < POW_CONE_TOL) {
+    f = POWF(x, a) * POWF(y, (1 - a)) - r;
+    if (ABS(f) < POW_CONE_TOL)
       break;
-    }
 
-    dxdr = pow_calcdxdr(x, xh, rh, r, a);
-    dydr = pow_calcdxdr(y, yh, rh, r, (1 - a));
+    dxdr = a * (rh - 2 * r) / (2 * x - xh);
+    dydr = (1 - a) * (rh - 2 * r) / (2 * y - yh);
     fp = pow_calc_fp(x, y, dxdr, dydr, a);
 
     r = MAX(r - f / fp, 0);
@@ -1334,56 +1154,53 @@ static void proj_power_cone(scs_float *v, scs_float a) {
   }
   v[0] = x;
   v[1] = y;
-  v[2] = (v[2] < 0) ? -(r) : (r);
+  v[2] = (v[2] < 0) ? -r : r;
 }
 
-/* project onto the primal K cone in the paper */
-/* the r_y vector determines the INVERSE metric, ie, project under the
+/* 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_float *r_y) {
-  scs_int i, status;
-  scs_int count = 0;
+  scs_int i, count = 0, status = 0;
   scs_float *r_box = SCS_NULL;
 #ifdef USE_SPECTRAL_CONES
   SPECTRAL_TIMING(SCS(timer) spec_mat_proj_timer;)
 #endif
 
-  if (k->z) { /* doesn't use r_y */
-    /* project onto primal zero / dual free cone */
+  /* 1. Zero Cone */
+  if (k->z) {
     memset(x, 0, k->z * sizeof(scs_float));
     count += k->z;
   }
 
-  if (k->l) { /* doesn't use r_y */
-    /* project onto positive orthant */
-    for (i = count; i < count + k->l; ++i) {
+  /* 2. Linear Cone (Non-negative orthant) */
+  if (k->l) {
+    for (i = count; i < count + k->l; ++i)
       x[i] = MAX(x[i], 0.0);
-    }
     count += k->l;
   }
 
-  if (k->bsize) { /* DOES use r_y */
-    if (r_y) {
+  /* 3. Box Cone */
+  if (k->bsize) {
+    if (r_y)
       r_box = &(r_y[count]);
-    }
-    /* project onto box cone */
     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 */
+    count += k->bsize;
   }
 
-  if (k->qsize && k->q) { /* doesn't use r_y */
-    /* project onto second-order cones */
+  /* 4. SOC */
+  if (k->qsize) {
     for (i = 0; i < k->qsize; ++i) {
       proj_soc(&(x[count]), k->q[i]);
       count += k->q[i];
     }
   }
 
-  if (k->ssize && k->s) { /* doesn't use r_y */
-    /* project onto PSD cones */
+  /* 5. PSD Cone */
+  if (k->ssize) {
     for (i = 0; i < k->ssize; ++i) {
 #ifdef USE_SPECTRAL_CONES
       SPECTRAL_TIMING(SCS(tic)(&spec_mat_proj_timer);)
@@ -1393,20 +1210,18 @@ static scs_int proj_cone(scs_float *x, const ScsCone *k, ScsConeWork *c,
       SPECTRAL_TIMING(c->tot_time_mat_cone_proj +=
                       SCS(tocq)(&spec_mat_proj_timer);)
 #endif
-      if (status < 0) {
+      if (status < 0)
         return status;
-      }
       count += get_sd_cone_size(k->s[i]);
     }
   }
 
-  if (k->cssize && k->cs) { /* doesn't use r_y */
-    /* project onto complex PSD cones */
+  /* 6. Complex PSD Cone */
+  if (k->cssize) {
     for (i = 0; i < k->cssize; ++i) {
       status = proj_complex_semi_definite_cone(&(x[count]), k->cs[i], c);
-      if (status < 0) {
+      if (status < 0)
         return status;
-      }
       count += get_csd_cone_size(k->cs[i]);
     }
   }
@@ -1416,15 +1231,17 @@ static scs_int proj_cone(scs_float *x, const ScsCone *k, ScsConeWork *c,
 #pragma omp parallel for
 #endif
     for (i = 0; i < k->ep + k->ed; ++i) {
-      /* provided in exp_cone.c */
       SCS(proj_pd_exp_cone)(&(x[count + 3 * i]), i < k->ep);
     }
     count += 3 * (k->ep + k->ed);
   }
-  if (k->psize && k->p) { /* doesn't use r_y */
+
+  /* 8. Power Cone */
+  if (k->psize) {
     scs_float v[3];
     scs_int idx;
-    /* don't use openmp for power cone
+    /* TODO: openmp not working well for power cone. */
+    /*
     ifdef _OPENMP
     pragma omp parallel for private(v, idx)
     endif
@@ -1432,16 +1249,14 @@ static scs_int proj_cone(scs_float *x, const ScsCone *k, ScsConeWork *c,
     for (i = 0; i < k->psize; ++i) { /* doesn't use r_y */
       idx = count + 3 * i;
       if (k->p[i] >= 0) {
-        /* primal power cone */
+        /* Primal power cone */
         proj_power_cone(&(x[idx]), k->p[i]);
       } else {
-        /* dual power cone, using Moreau */
+        /* Dual power cone via Moreau */
         v[0] = -x[idx];
         v[1] = -x[idx + 1];
         v[2] = -x[idx + 2];
-
         proj_power_cone(v, -k->p[i]);
-
         x[idx] += v[0];
         x[idx + 1] += v[1];
         x[idx + 2] += v[2];
@@ -1451,99 +1266,79 @@ static scs_int proj_cone(scs_float *x, const ScsCone *k, ScsConeWork *c,
   }
 
 #ifdef USE_SPECTRAL_CONES
-  scs_int offset_log_cone = 0; /* used for warmstarting log-cone projections */
-  /* project onto logdet cones */
-  if (k->dsize && k->d) {
+  /* Spectral Cones (Logdet, Nuclear, Ell1, Sum Largest) */
+  scs_int offset_log = 0;
+
+  if (k->dsize) {
     for (i = 0; i < k->dsize; ++i) {
       SPECTRAL_TIMING(SCS(tic)(&spec_mat_proj_timer);)
-      status = SCS(proj_logdet_cone)(&(x[count]), k->d[i], c, offset_log_cone,
+      status = SCS(proj_logdet_cone)(&(x[count]), k->d[i], c, offset_log,
                                      c->log_cone_warmstarts + i);
       SPECTRAL_TIMING(c->tot_time_mat_cone_proj +=
                       SCS(tocq)(&spec_mat_proj_timer);)
-      offset_log_cone += k->d[i] + 2;
-      if (status < 0) {
+      if (status < 0)
         return status;
-      }
-      count += (get_sd_cone_size(k->d[i]) + 2);
+      offset_log += k->d[i] + 2;
+      count += get_sd_cone_size(k->d[i]) + 2;
     }
   }
-  /* project onto nuclear norm cones */
-  if (k->nucsize && k->nuc_m && k->nuc_n) {
+  if (k->nucsize) {
     for (i = 0; i < k->nucsize; ++i) {
       SPECTRAL_TIMING(SCS(tic)(&spec_mat_proj_timer);)
       status = SCS(proj_nuclear_cone)(&(x[count]), k->nuc_m[i], k->nuc_n[i], c);
       SPECTRAL_TIMING(c->tot_time_mat_cone_proj +=
                       SCS(tocq)(&spec_mat_proj_timer);)
-      if (status < 0) {
+      if (status < 0)
         return status;
-      }
-      count += (k->nuc_m[i] * k->nuc_n[i] + 1);
+      count += k->nuc_m[i] * k->nuc_n[i] + 1;
     }
   }
-  /* project onto ell1-norm cones */
-  if (k->ell1_size && k->ell1) {
+  if (k->ell1_size) {
     for (i = 0; i < k->ell1_size; ++i) {
       SCS(proj_ell_one)(&(x[count]), k->ell1[i], c);
-      count += (k->ell1[i] + 1);
+      count += k->ell1[i] + 1;
     }
   }
-  /* project onto sum-of-largest eigenvalues cone */
-  if (k->sl_size && k->sl_n && k->sl_k) {
+  if (k->sl_size) {
     for (i = 0; i < k->sl_size; ++i) {
       SPECTRAL_TIMING(SCS(tic)(&spec_mat_proj_timer);)
       status =
           SCS(proj_sum_largest_evals)(&(x[count]), k->sl_n[i], k->sl_k[i], c);
       SPECTRAL_TIMING(c->tot_time_mat_cone_proj +=
                       SCS(tocq)(&spec_mat_proj_timer);)
-      if (status < 0) {
+      if (status < 0)
         return status;
-      }
-      count += (get_sd_cone_size(k->sl_n[i]) + 1);
+      count += get_sd_cone_size(k->sl_n[i]) + 1;
     }
   }
-
 #endif
-  /* project onto OTHER cones */
 
   return 0;
 }
 
-#ifdef USE_SPECTRAL_CONES
-static scs_int set_up_ell1_cone_work_space(ScsConeWork *c, const ScsCone *k) {
-  scs_int i;
-  scs_int n_max = 0;
-
-  if (k->ell1_size > 0) {
-    for (i = 0; i < k->ell1_size; ++i) {
-      n_max = MAX(k->ell1[i], n_max);
-    }
-
-    c->work_ell1 = (Value_index *)scs_calloc(n_max, sizeof(Value_index));
-    c->work_ell1_proj = (scs_float *)scs_calloc(n_max + 1, sizeof(scs_float));
-    if (!c->work_ell1 || !c->work_ell1_proj) {
-      return -1;
-    }
-  }
-
-  return 0;
-}
-#endif
+/*
+ * Public API
+ */
 
 ScsConeWork *SCS(init_cone)(ScsCone *k, scs_int m) {
   ScsConeWork *c = (ScsConeWork *)scs_calloc(1, sizeof(ScsConeWork));
+  if (!c)
+    return SCS_NULL;
+
   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)
+
+  /* Set up workspaces if matrix cones are present */
+  if ((k->ssize && k->s) || (k->cssize && k->cs)
 #ifdef USE_SPECTRAL_CONES
-      || (k->dsize && k->d) || (k->nucsize && k->nuc_m && k->nuc_n) ||
-      (k->sl_size && k->sl_k && k->sl_n)
+      || (k->dsize) || (k->nucsize) || (k->sl_size)
 #endif
   ) {
-    if (set_up_sd_cone_work_space(c, k) < 0) {
+    if (set_up_cone_work_spaces(c, k) < 0) {
       SCS(finish_cone)(c);
       return SCS_NULL;
     }
@@ -1558,16 +1353,10 @@ ScsConeWork *SCS(init_cone)(ScsCone *k, scs_int m) {
   }
 #endif
 
-  if (k->cssize && k->cs) {
-    if (set_up_csd_cone_work_space(c, k) < 0) {
-      SCS(finish_cone)(c);
-      return SCS_NULL;
-    }
-  }
   return c;
 }
 
-void scale_box_cone(ScsCone *k, ScsConeWork *c, ScsScaling *scal) {
+void scale_box_cone(ScsCone *k, ScsConeWork *c, const ScsScaling *scal) {
   if (k->bsize && k->bu && k->bl) {
     c->box_t_warm_start = 1.;
     if (scal) {
@@ -1589,34 +1378,38 @@ void scale_box_cone(ScsCone *k, ScsConeWork *c, ScsScaling *scal) {
     `||x||_R = \sqrt{x ' R x}`.
 
 */
-scs_int SCS(proj_dual_cone)(scs_float *x, ScsConeWork *c, ScsScaling *scal,
-                            scs_float *r_y) {
+scs_int SCS(proj_dual_cone)(scs_float *x, ScsConeWork *c,
+                            const ScsScaling *scal, scs_float *r_y) {
   scs_int status, i;
   ScsCone *k = c->k;
 
   if (!c->scaled_cones) {
-    scale_box_cone(k, c, scal);
+    /* Normalize box cone if applicable */
+    if (k->bsize && k->bu && k->bl) {
+      c->box_t_warm_start = 1.;
+      if (scal)
+        normalize_box_cone(k, &(scal->D[k->z + k->l]), k->bsize);
+    }
     c->scaled_cones = 1;
   }
 
-  /* copy s = x */
+  /* 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;
+    x[i] *= r_y ? -r_y[i] : -1.0;
   }
 
-  /* project -x onto cone, x -> \Pi_{C^*}^{R^{-1}}(-x) under r_y metric */
+  /* 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 )  */
+  /* Return x + R^{-1} \Pi_{C^*}^{R^{-1}} ( -x ) */
   for (i = 0; i < c->m; ++i) {
-    if (r_y) {
+    if (r_y)
       x[i] = x[i] / r_y[i] + c->s[i];
-    } else {
+    else
       x[i] += c->s[i];
-    }
   }
 
   return status;