scs 0.5.1 → 0.5.2

data/vendor/scs/src/cones.c

@@ -3,6 +3,19 @@
 #include "scs.h"
 #include "scs_blas.h" /* contains BLAS(X) macros and type info */
 #include "util.h"
+#include <complex.h>
+
+// 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.
+#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
 
 #define BOX_CONE_MAX_ITERS (25)
 #define POW_CONE_TOL (1e-9)
@@ -20,17 +33,51 @@ extern "C" {
 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);
+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,
+                  scs_float *abstol, blas_int *m, scs_float *w,
+                  SCS_BLAS_COMPLEX_TYPE *z, blas_int *ldz, blas_int *isuppz,
+                  SCS_BLAS_COMPLEX_TYPE *cwork, blas_int *lcwork,
+                  scs_float *rwork, blas_int *lrwork, blas_int *iwork,
+                  blas_int *liwork, blas_int *info);
+
 blas_int BLAS(syrk)(const char *uplo, const char *trans, const blas_int *n,
                     const blas_int *k, const scs_float *alpha,
                     const scs_float *a, const blas_int *lda,
                     const scs_float *beta, scs_float *c, const blas_int *ldc);
+
+blas_int BLASC(herk)(const char *uplo, const char *trans, const blas_int *n,
+                     const blas_int *k, const scs_float *alpha,
+                     const SCS_BLAS_COMPLEX_TYPE *a, const blas_int *lda,
+                     const scs_float *beta, SCS_BLAS_COMPLEX_TYPE *c,
+                     const blas_int *ldc);
+
 void BLAS(scal)(const blas_int *n, const scs_float *sa, scs_float *sx,
                 const blas_int *incx);
+void BLASC(scal)(const blas_int *n, const SCS_BLAS_COMPLEX_TYPE *sa,
+                 SCS_BLAS_COMPLEX_TYPE *sx, const blas_int *incx);
+
+#ifdef USE_SPECTRAL_CONES
+void BLAS(gesvd)(const char *jobu, const char *jobvt, const blas_int *m,
+                 const blas_int *n, scs_float *a, const blas_int *lda,
+                 scs_float *s, scs_float *u, const blas_int *ldu, scs_float *vt,
+                 const blas_int *ldvt, scs_float *work, const blas_int *lwork,
+                 blas_int *info);
+
+// 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,
+                               ScsConeWork *c);
+void SCS(proj_ell_one)(scs_float *tx, scs_int n, ScsConeWork *c);
+scs_int SCS(proj_sum_largest_evals)(scs_float *tX, scs_int n, scs_int k,
+                                    ScsConeWork *c);
+#endif
 
 #ifdef __cplusplus
 }
 #endif
-
 #endif
 
 /* Forward declare exponential cone projection routine.
@@ -48,8 +95,24 @@ void SCS(free_cone)(ScsCone *k) {
       scs_free(k->q);
     if (k->s)
       scs_free(k->s);
+    if (k->cs)
+      scs_free(k->cs);
     if (k->p)
       scs_free(k->p);
+#ifdef USE_SPECTRAL_CONES
+    if (k->d)
+      scs_free(k->d);
+    if (k->nuc_m)
+      scs_free(k->nuc_m);
+    if (k->nuc_n)
+      scs_free(k->nuc_n);
+    if (k->ell1)
+      scs_free(k->ell1);
+    if (k->sl_n)
+      scs_free(k->sl_n);
+    if (k->sl_k)
+      scs_free(k->sl_k);
+#endif
     scs_free(k);
   }
 }
@@ -80,6 +143,13 @@ void SCS(deep_copy_cone)(ScsCone *dest, const ScsCone *src) {
   } else {
     dest->s = SCS_NULL;
   }
+  /* copy complex PSD cone */
+  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 */
   if (src->psize > 0) {
     dest->p = (scs_float *)scs_calloc(src->psize, sizeof(scs_float));
@@ -87,6 +157,42 @@ void SCS(deep_copy_cone)(ScsCone *dest, const ScsCone *src) {
   } else {
     dest->p = SCS_NULL;
   }
+#ifdef USE_SPECTRAL_CONES
+  /* copy logdet cone */
+  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*/
+  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_n, src->nuc_n, src->nucsize * sizeof(scs_int));
+  } else {
+    dest->nuc_m = SCS_NULL;
+    dest->nuc_n = SCS_NULL;
+  }
+  /* copy ell1-norm cone */
+  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 */
+  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_k, src->sl_k, src->sl_size * sizeof(scs_int));
+  } else {
+    dest->sl_n = SCS_NULL;
+    dest->sl_k = SCS_NULL;
+  }
+#endif
 }
 
 /* set the vector of rho y terms, based on scale and cones */
@@ -100,6 +206,7 @@ void SCS(set_r_y)(const ScsConeWork *c, scs_float scale, scs_float *r_y) {
      */
     r_y[i] = 1.0 / (1000. * scale);
   }
+
   /* others */
   for (i = c->k->z; i < c->m; ++i) {
     r_y[i] = 1.0 / scale;
@@ -126,15 +233,25 @@ 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
  * 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, count = 0;
+  scs_int i, s_cone_sz, cs_cone_sz, 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;
+#else
   scs_int cone_boundaries_len =
-      1 + k->qsize + k->ssize + k->ed + k->ep + k->psize;
+      1 + 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;
@@ -143,11 +260,17 @@ void set_cone_boundaries(const ScsCone *k, ScsConeWork *c) {
     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; /* add ssize here not ssize * (ssize + 1) / 2 */
+  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;
@@ -158,6 +281,28 @@ void set_cone_boundaries(const ScsCone *k, ScsConeWork *c) {
     b[count + i] = 3;
   }
   count += k->psize;
+#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;
+#endif
   /* other cones */
   c->cone_boundaries = b;
   c->cone_boundaries_len = cone_boundaries_len;
@@ -175,6 +320,11 @@ static scs_int get_full_cone_dims(const ScsCone *k) {
       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;
   }
@@ -184,6 +334,28 @@ static scs_int get_full_cone_dims(const ScsCone *k) {
   if (k->psize) {
     c += 3 * 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;
+    }
+  }
+#endif
   return c;
 }
 
@@ -238,6 +410,18 @@ scs_int SCS(validate_cones)(const ScsData *d, const ScsCone *k) {
       }
     }
   }
+  if (k->cssize && k->cs) {
+    if (k->cssize < 0) {
+      scs_printf("complex psd cone dimension error\n");
+      return -1;
+    }
+    for (i = 0; i < k->cssize; ++i) {
+      if (k->cs[i] < 0) {
+        scs_printf("complex psd cone dimension error\n");
+        return -1;
+      }
+    }
+  }
   if (k->ed && k->ed < 0) {
     scs_printf("ep cone dimension error\n");
     return -1;
@@ -258,6 +442,52 @@ scs_int SCS(validate_cones)(const ScsData *d, const ScsCone *k) {
       }
     }
   }
+#ifdef USE_SPECTRAL_CONES
+  if (k->dsize && k->d) {
+    if (k->dsize < 0) {
+      scs_printf("logdet cone dimension error\n");
+      return -1;
+    }
+    for (i = 0; i < k->dsize; ++i) {
+      if (k->d[i] < 1) {
+        scs_printf("logdet cone dimension error\n");
+        return -1;
+      }
+    }
+  }
+  if (k->nucsize && k->nuc_m && k->nuc_n) {
+    if (k->nucsize < 0) {
+      scs_printf("nuclear cone dimension error\n");
+      return -1;
+    }
+    for (i = 0; i < k->nucsize; ++i) {
+      if (k->nuc_m[i] < 1 || k->nuc_n[i] < 1 || k->nuc_n[i] > k->nuc_m[i]) {
+        scs_printf("nuclear norm cone dimension error\n");
+        return -1;
+      }
+    }
+  }
+  if (k->ell1_size && k->ell1) {
+    if (k->ell1_size < 0) {
+      scs_printf("ell1 cone dimension error\n");
+      return -1;
+    }
+    for (i = 0; i < k->ell1_size; ++i) {
+      if (k->ell1[i] < 1) {
+        scs_printf("ell1 cone dimension error\n");
+        return -1;
+      }
+    }
+  }
+  if (k->sl_size && k->sl_n && k->sl_k) {
+    for (i = 0; i < k->sl_size; ++i) {
+      if ((k->sl_k[i] >= k->sl_n[i]) || k->sl_k[i] <= 0) {
+        scs_printf("sum-of-largest-eigenvalues cone dimension error\n");
+        return -1;
+      }
+    }
+  }
+#endif
   return 0;
 }
 
@@ -266,15 +496,33 @@ void SCS(finish_cone)(ScsConeWork *c) {
   if (c->Xs) {
     scs_free(c->Xs);
   }
+  if (c->cXs) {
+    scs_free(c->cXs);
+  }
   if (c->Z) {
     scs_free(c->Z);
   }
+  if (c->cZ) {
+    scs_free(c->cZ);
+  }
   if (c->e) {
     scs_free(c->e);
   }
+  if (c->isuppz) {
+    scs_free(c->isuppz);
+  }
   if (c->work) {
     scs_free(c->work);
   }
+  if (c->iwork) {
+    scs_free(c->iwork);
+  }
+  if (c->cwork) {
+    scs_free(c->cwork);
+  }
+  if (c->rwork) {
+    scs_free(c->rwork);
+  }
 #endif
   if (c->cone_boundaries) {
     scs_free(c->cone_boundaries);
@@ -282,6 +530,38 @@ void SCS(finish_cone)(ScsConeWork *c) {
   if (c->s) {
     scs_free(c->s);
   }
+#ifdef USE_SPECTRAL_CONES
+  if (c->work_logdet) {
+    scs_free(c->work_logdet);
+  }
+  if (c->saved_log_projs) {
+    scs_free(c->saved_log_projs);
+  }
+  if (c->s_nuc) {
+    scs_free(c->s_nuc);
+  }
+  if (c->u_nuc) {
+    scs_free(c->u_nuc);
+  }
+  if (c->vt_nuc) {
+    scs_free(c->vt_nuc);
+  }
+  if (c->work_nuc) {
+    scs_free(c->work_nuc);
+  }
+  if (c->work_sum_of_largest) {
+    scs_free(c->work_sum_of_largest);
+  }
+  if (c->log_cone_warmstarts) {
+    scs_free(c->log_cone_warmstarts);
+  }
+  if (c->work_ell1) {
+    scs_free(c->work_ell1);
+  }
+  if (c->work_ell1_proj) {
+    scs_free(c->work_ell1_proj);
+  }
+#endif
   if (c) {
     scs_free(c);
   }
@@ -289,7 +569,7 @@ void SCS(finish_cone)(ScsConeWork *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;
+  scs_int i, soc_vars, sd_vars, csd_vars;
   sprintf(tmp, "cones: ");
   if (k->z) {
     sprintf(tmp + strlen(tmp), "\t  z: primal zero / dual free vars: %li\n",
@@ -317,6 +597,14 @@ char *SCS(get_cone_header)(const ScsCone *k) {
     sprintf(tmp + strlen(tmp), "\t  s: psd vars: %li, ssize: %li\n",
             (long)sd_vars, (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]);
+    }
+    sprintf(tmp + strlen(tmp), "\t  cs: complex psd vars: %li, ssize: %li\n",
+            (long)csd_vars, (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));
@@ -325,6 +613,43 @@ char *SCS(get_cone_header)(const ScsCone *k) {
     sprintf(tmp + strlen(tmp), "\t  p: primal + dual power vars: %li\n",
             (long)(3 * k->psize));
   }
+#ifdef USE_SPECTRAL_CONES
+  scs_int ell1_vars, log_vars, nuc_vars, sl_vars;
+  log_vars = 0;
+  if (k->dsize && k->d) {
+    for (i = 0; i < k->dsize; i++) {
+      log_vars += get_sd_cone_size(k->d[i]) + 2;
+    }
+    sprintf(tmp + strlen(tmp), "\t  d: logdet vars: %li, dsize: %li\n",
+            (long)log_vars, (long)k->dsize);
+  }
+  nuc_vars = 0;
+  if (k->nucsize && k->nuc_m && k->nuc_n) {
+    for (i = 0; i < k->nucsize; i++) {
+      nuc_vars += k->nuc_m[i] * k->nuc_n[i] + 1;
+    }
+    sprintf(tmp + strlen(tmp), "\t  nuc: nuclear vars: %li, nucsize: %li\n",
+            (long)nuc_vars, (long)k->nucsize);
+  }
+  ell1_vars = 0;
+  if (k->ell1_size && k->ell1) {
+    for (i = 0; i < k->ell1_size; ++i) {
+      ell1_vars += k->ell1[i];
+    }
+    sprintf(tmp + strlen(tmp), "\t  ell1: ell1 vars: %li, ell1_size: %li\n",
+            (long)ell1_vars, (long)k->ell1_size);
+  }
+
+  sl_vars = 0;
+  if (k->sl_size && k->sl_n) {
+    for (i = 0; i < k->sl_size; ++i) {
+      sl_vars += get_sd_cone_size(k->sl_n[i]) + 1;
+    }
+    sprintf(tmp + strlen(tmp), "\t  sl: sl vars: %li, sl_size: %li\n",
+            (long)sl_vars, (long)k->sl_size);
+  }
+#endif
+
   return tmp;
 }
 
@@ -340,31 +665,133 @@ static scs_int set_up_sd_cone_work_space(ScsConeWork *c, const ScsCone *k) {
 #define _STR(tok) _STR_EXPAND(tok)
   scs_printf("BLAS(func) = '%s'\n", _STR(BLAS(func)));
 #endif
-  /* eigenvector decomp workspace */
+
+  // ----------------------------------------------------------------------
+  //   compute max dimension needed for eigenvalue decomposition workspace
+  //   (all cones appearing in the next section of code require eigenvalue
+  //    decompositions)
+  // ----------------------------------------------------------------------
   for (i = 0; i < k->ssize; ++i) {
     if (k->s[i] > n_max) {
       n_max = (blas_int)k->s[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];
+    }
+  }
+
+  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];
+    }
+  }
+
+  // --------------------------------------------------------------------------
+  //         allocate workspace for logdeterminant cones
+  // --------------------------------------------------------------------------
+  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) {
+      return -1;
+    }
+  }
+
+  // ---------------------------------------------------------------
+  //        allocate workspace for sum-of-largest-eigenvalues cone
+  // ---------------------------------------------------------------
+  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) {
+      return -1;
+    }
+  }
+  n_max = MAX(n_max, n_max_logdet);
+  n_max = MAX(n_max, 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));
   c->e = (scs_float *)scs_calloc(n_max, sizeof(scs_float));
 
   /* workspace query */
-  BLAS(syev)
-  ("Vectors", "Lower", &n_max, c->Xs, &n_max, SCS_NULL, &wkopt, &neg_one,
-   &info);
+  BLAS(syev)("Vectors", "Lower", &n_max, c->Xs, &n_max, SCS_NULL, &wkopt,
+             &neg_one, &info);
 
   if (info != 0) {
     scs_printf("FATAL: syev workspace query failure, info = %li\n", (long)info);
     return -1;
   }
+
   c->lwork = (blas_int)(wkopt + 1); /* +1 for int casting safety */
   c->work = (scs_float *)scs_calloc(c->lwork, sizeof(scs_float));
 
   if (!c->Xs || !c->Z || !c->e || !c->work) {
     return -1;
   }
+
+#ifdef USE_SPECTRAL_CONES
+  // ------------------------------------------------------------------
+  //              allocate memory for nuclear norm cone
+  // ------------------------------------------------------------------
+  if (k->nucsize > 0) {
+    blas_int m_max_nuc = 1;
+    blas_int n_max_nuc = 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];
+      }
+    }
+
+    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) {
+      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));
+
+    if (!c->lwork_nuc || !c->work_nuc) {
+      return -1;
+    }
+
+    if (info != 0) {
+      scs_printf("FATAL: gesvd workspace query failure, info = %li\n",
+                 (long)info);
+      return -1;
+    }
+  }
+#endif
+
   return 0;
 #else
   for (i = 0; i < k->ssize; i++) {
@@ -377,6 +804,38 @@ static scs_int set_up_sd_cone_work_space(ScsConeWork *c, const ScsCone *k) {
       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;
+    }
+  }
+
+  for (i = 0; i < k->nucsize; i++) {
+    if (k->nuc_m[i] > 1 || k->nuc_n[i] > 1) {
+      has_spectral_cones = true;
+      break;
+    }
+  }
+
+  for (i = 0; i < k->sl_size; i++) {
+    if (k->sl_n[i] > 1) {
+      has_spectral_cones = true;
+      break;
+    }
+  }
+
+  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");
+    return -1;
+  }
+#endif
   return 0;
 #endif
 }
@@ -386,6 +845,7 @@ 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;
@@ -435,6 +895,8 @@ static scs_int proj_semi_definite_cone(scs_float *X, const scs_int n,
     }
   }
 
+  SCS(tic)(&_timer);
+
   first_idx = -1;
   /* e is eigvals in ascending order, find first entry > 0 */
   for (i = 0; i < n; ++i) {
@@ -476,7 +938,197 @@ static scs_int proj_semi_definite_cone(scs_float *X, const scs_int n,
 #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, 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) */
+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) {
+    return 0;
+  }
+  if (n == 1) {
+    X[0] = MAX(X[0], 0.);
+    return 0;
+  }
+
+#ifdef USE_LAPACK
+
+  /* copy lower triangular matrix into full 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]),
+           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;
+    }
+  }
+
+  first_idx = -1;
+  /* e is eigvals in ascending order, find first entry > 0 */
+  for (i = 0; i < n; ++i) {
+    if (e[i] > 0) {
+      first_idx = i;
+      break;
+    }
+  }
+
+  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' */
+  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);
+
+  /* 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 */
+
+  /* extract just lower triangular matrix */
+  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]),
+           2 * (n - i - 1) * sizeof(scs_float));
+  }
+  X[n * n - 1] = 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
 }
@@ -509,7 +1161,7 @@ static scs_float pow_calc_fp(scs_float x, scs_float y, scs_float dxdr,
  *  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 prooperty)
+ *    (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 } =>
@@ -676,6 +1328,9 @@ 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;
+#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 */
@@ -712,7 +1367,14 @@ static scs_int proj_cone(scs_float *x, const ScsCone *k, ScsConeWork *c,
   if (k->ssize && k->s) { /* doesn't use r_y */
     /* project onto PSD cones */
     for (i = 0; i < k->ssize; ++i) {
+#ifdef USE_SPECTRAL_CONES
+      SPECTRAL_TIMING(SCS(tic)(&spec_mat_proj_timer);)
+#endif
       status = proj_semi_definite_cone(&(x[count]), k->s[i], c);
+#ifdef USE_SPECTRAL_CONES
+      SPECTRAL_TIMING(c->tot_time_mat_cone_proj +=
+                      SCS(tocq)(&spec_mat_proj_timer);)
+#endif
       if (status < 0) {
         return status;
       }
@@ -720,6 +1382,17 @@ static scs_int proj_cone(scs_float *x, const ScsCone *k, ScsConeWork *c,
     }
   }
 
+  if (k->cssize && k->cs) { /* doesn't use r_y */
+    /* project onto complex PSD cones */
+    for (i = 0; i < k->cssize; ++i) {
+      status = proj_complex_semi_definite_cone(&(x[count]), k->cs[i], c);
+      if (status < 0) {
+        return status;
+      }
+      count += get_csd_cone_size(k->cs[i]);
+    }
+  }
+
   if (k->ep || k->ed) { /* doesn't use r_y */
 #ifdef _OPENMP
 #pragma omp parallel for
@@ -758,23 +1431,121 @@ static scs_int proj_cone(scs_float *x, const ScsCone *k, ScsConeWork *c,
     }
     count += 3 * k->psize;
   }
+
+#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) {
+    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,
+                                     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) {
+        return status;
+      }
+      count += (get_sd_cone_size(k->d[i]) + 2);
+    }
+  }
+  /* project onto nuclear norm cones */
+  if (k->nucsize && k->nuc_m && k->nuc_n) {
+    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) {
+        return status;
+      }
+      count += (k->nuc_m[i] * k->nuc_n[i] + 1);
+    }
+  }
+  /* project onto ell1-norm cones */
+  if (k->ell1_size && k->ell1) {
+    for (i = 0; i < k->ell1_size; ++i) {
+      SCS(proj_ell_one)(&(x[count]), k->ell1[i], c);
+      count += (k->ell1[i] + 1);
+    }
+  }
+  /* project onto sum-of-largest eigenvalues cone */
+  if (k->sl_size && k->sl_n && k->sl_k) {
+    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) {
+        return status;
+      }
+      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
 
 ScsConeWork *SCS(init_cone)(ScsCone *k, scs_int m) {
   ScsConeWork *c = (ScsConeWork *)scs_calloc(1, sizeof(ScsConeWork));
   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 ((k->ssize && k->s)
+#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)
+#endif
+  ) {
     if (set_up_sd_cone_work_space(c, k) < 0) {
       SCS(finish_cone)(c);
       return SCS_NULL;
     }
   }
+
+#ifdef USE_SPECTRAL_CONES
+  if (k->ell1_size > 0 && k->ell1) {
+    if (set_up_ell1_cone_work_space(c, k) < 0) {
+      SCS(finish_cone)(c);
+      return SCS_NULL;
+    }
+  }
+#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;
 }