scs 0.2.2 → 0.3.2

data/vendor/scs/src/scs_version.c

@@ -1,5 +1,13 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include "glbopts.h"
 
-const char *SCS(version)(void) { return SCS_VERSION; }
-size_t SCS(sizeof_int)(void) { return sizeof(scs_int); }
-size_t SCS(sizeof_float)(void) { return sizeof(scs_float); }
+const char *scs_version(void) {
+  return SCS_VERSION;
+}
+
+#ifdef __cplusplus
+}
+#endif

data/vendor/scs/src/util.c

@@ -2,12 +2,16 @@
 
 #include "glbopts.h"
 #include "linsys.h"
+#include "scs_matrix.h"
 
 /* return milli-seconds */
 #if (defined NOTIMER)
 
-void SCS(tic)(SCS(timer) * t) {}
-scs_float SCS(tocq)(SCS(timer) * t) { return NAN; }
+void SCS(tic)(SCS(timer) * t) {
+}
+scs_float SCS(tocq)(SCS(timer) * t) {
+  return NAN;
+}
 
 #elif (defined _WIN32 || _WIN64 || defined _WINDLL)
 
@@ -46,7 +50,9 @@ scs_float SCS(tocq)(SCS(timer) * t) {
 
 #else
 
-void SCS(tic)(SCS(timer) * t) { clock_gettime(CLOCK_MONOTONIC, &t->tic); }
+void SCS(tic)(SCS(timer) * t) {
+  clock_gettime(CLOCK_MONOTONIC, &t->tic);
+}
 
 scs_float SCS(tocq)(SCS(timer) * t) {
   struct timespec temp;
@@ -65,109 +71,29 @@ scs_float SCS(tocq)(SCS(timer) * t) {
 
 #endif
 
-scs_float SCS(toc)(SCS(timer) * t) {
-  scs_float time = SCS(tocq)(t);
-  scs_printf("time: %8.4f milli-seconds.\n", time);
-  return time;
-}
-
-scs_float SCS(str_toc)(char *str, SCS(timer) * t) {
-  scs_float time = SCS(tocq)(t);
-  scs_printf("%s - time: %8.4f milli-seconds.\n", str, time);
-  return time;
-}
-
-void SCS(print_cone_data)(const ScsCone *k) {
-  scs_int i;
-  scs_printf("num zeros = %i\n", (int)k->f);
-  scs_printf("num LP = %i\n", (int)k->l);
-  scs_printf("num SOCs = %i\n", (int)k->qsize);
-  scs_printf("soc array:\n");
-  for (i = 0; i < k->qsize; i++) {
-    scs_printf("%i\n", (int)k->q[i]);
-  }
-  scs_printf("num SDCs = %i\n", (int)k->ssize);
-  scs_printf("sdc array:\n");
-  for (i = 0; i < k->ssize; i++) {
-    scs_printf("%i\n", (int)k->s[i]);
-  }
-  scs_printf("num ep = %i\n", (int)k->ep);
-  scs_printf("num ed = %i\n", (int)k->ed);
-  scs_printf("num PCs = %i\n", (int)k->psize);
-  scs_printf("pow array:\n");
-  for (i = 0; i < k->psize; i++) {
-    scs_printf("%4f\n", (double)k->p[i]);
-  }
-}
-
-void SCS(print_work)(const ScsWork *w) {
-  scs_int i, l = w->n + w->m;
-  scs_printf("\n u_t is \n");
-  for (i = 0; i < l; i++) {
-    scs_printf("%f\n", w->u_t[i]);
-  }
-  scs_printf("\n u is \n");
-  for (i = 0; i < l; i++) {
-    scs_printf("%f\n", w->u[i]);
-  }
-  scs_printf("\n v is \n");
-  for (i = 0; i < l; i++) {
-    scs_printf("%f\n", w->v[i]);
-  }
-}
-
-void SCS(print_data)(const ScsData *d) {
-  scs_printf("m = %i\n", (int)d->m);
-  scs_printf("n = %i\n", (int)d->n);
-
-  scs_printf("max_iters = %i\n", (int)d->stgs->max_iters);
-  scs_printf("verbose = %i\n", (int)d->stgs->verbose);
-  scs_printf("normalize = %i\n", (int)d->stgs->normalize);
-  scs_printf("warm_start = %i\n", (int)d->stgs->warm_start);
-  scs_printf("acceleration_lookback = %i\n",
-             (int)d->stgs->acceleration_lookback);
-  scs_printf("eps = %4f\n", d->stgs->eps);
-  scs_printf("alpha = %4f\n", d->stgs->alpha);
-  scs_printf("rho_x = %4f\n", d->stgs->rho_x);
-  scs_printf("cg_rate = %4f\n", d->stgs->cg_rate);
-  scs_printf("scale = %4f\n", d->stgs->scale);
-  scs_printf("write_data_filename = %s\n",
-             (char *)d->stgs->write_data_filename);
-}
-
-void SCS(print_array)(const scs_float *arr, scs_int n, const char *name) {
-  scs_int i, j, k = 0;
-  scs_int num_on_one_line = 10;
-  scs_printf("\n");
-  for (i = 0; i < n / num_on_one_line; ++i) {
-    for (j = 0; j < num_on_one_line; ++j) {
-      scs_printf("%s[%li] = %4f, ", name, (long)k, arr[k]);
-      k++;
-    }
-    scs_printf("\n");
-  }
-  for (j = k; j < n; ++j) {
-    scs_printf("%s[%li] = %4f, ", name, (long)j, arr[j]);
-  }
-  scs_printf("\n");
-}
-
-void SCS(free_data)(ScsData *d, ScsCone *k) {
+void SCS(free_data)(ScsData *d, ScsCone *k, ScsSettings *stgs) {
   if (d) {
     scs_free(d->b);
     scs_free(d->c);
-    scs_free(d->stgs);
     if (d->A) {
-      SCS(free_a_matrix)(d->A);
+      SCS(free_scs_matrix)(d->A);
+    }
+    if (d->P) {
+      SCS(free_scs_matrix)(d->P);
     }
     scs_free(d);
   }
   if (k) {
+    scs_free(k->bu);
+    scs_free(k->bl);
     scs_free(k->q);
     scs_free(k->s);
     scs_free(k->p);
     scs_free(k);
   }
+  if (stgs) {
+    scs_free(stgs);
+  }
 }
 
 void SCS(free_sol)(ScsSolution *sol) {
@@ -179,18 +105,23 @@ void SCS(free_sol)(ScsSolution *sol) {
   }
 }
 
-/* assumes d->stgs already allocated memory */
-void SCS(set_default_settings)(ScsData *d) {
+/* assumes stgs already allocated memory */
+void scs_set_default_settings(ScsSettings *stgs) {
   /* These constants are defined in include/glbopts.h */
-  d->stgs->max_iters = MAX_ITERS;
-  d->stgs->eps = EPS;
-  d->stgs->alpha = ALPHA;
-  d->stgs->rho_x = RHO_X;
-  d->stgs->scale = SCALE;
-  d->stgs->cg_rate = CG_RATE;
-  d->stgs->verbose = VERBOSE;
-  d->stgs->normalize = NORMALIZE;
-  d->stgs->warm_start = WARM_START;
-  d->stgs->acceleration_lookback = ACCELERATION_LOOKBACK;
-  d->stgs->write_data_filename = WRITE_DATA_FILENAME;
+  stgs->max_iters = MAX_ITERS;
+  stgs->eps_abs = EPS_ABS;
+  stgs->eps_rel = EPS_REL;
+  stgs->eps_infeas = EPS_INFEAS;
+  stgs->alpha = ALPHA;
+  stgs->rho_x = RHO_X;
+  stgs->scale = SCALE;
+  stgs->verbose = VERBOSE;
+  stgs->normalize = NORMALIZE;
+  stgs->warm_start = WARM_START;
+  stgs->acceleration_lookback = ACCELERATION_LOOKBACK;
+  stgs->acceleration_interval = ACCELERATION_INTERVAL;
+  stgs->adaptive_scale = ADAPTIVE_SCALE;
+  stgs->write_data_filename = WRITE_DATA_FILENAME;
+  stgs->log_csv_filename = LOG_CSV_FILENAME;
+  stgs->time_limit_secs = TIME_LIMIT_SECS;
 }

data/vendor/scs/test/minunit.h

@@ -1,13 +1,27 @@
 /* Taken from http://www.jera.com/techinfo/jtns/jtn002.html */
 
 /* Simple Macros for testing */
-#define mu_assert(message, test) \
-  do {                           \
-    if (!(test)) return message; \
+#define mu_assert_less(message, a, b)                                          \
+  do {                                                                         \
+    if (a > b) {                                                               \
+      scs_printf("%s: %1.3e > %1.3e\n", message, a, b);                        \
+      return message;                                                          \
+    }                                                                          \
   } while (0)
-#define mu_run_test(test)         \
-  do {                            \
-    const char *message = test(); \
-    tests_run++;                  \
-    if (message) return message;  \
+#define mu_assert(message, test)                                               \
+  do {                                                                         \
+    if (!(test))                                                               \
+      return message;                                                          \
+  } while (0)
+#define mu_run_test(test) _mu_run_test(#test, test)
+
+#define _mu_run_test(name, test)                                               \
+  do {                                                                         \
+    scs_printf("*********************************************************\n"); \
+    scs_printf("Running test: %s\n", name);                                    \
+    const char *message = test();                                              \
+    tests_run++;                                                               \
+    scs_printf("*********************************************************\n"); \
+    if (message)                                                               \
+      return message;                                                          \
   } while (0)

data/vendor/scs/test/problem_utils.h

@@ -1,34 +1,24 @@
 #ifndef PUTILS_H_GUARD
 #define PUTILS_H_GUARD
 
-#include "amatrix.h"
 #include "cones.h"
 #include "linalg.h"
+#include "linsys.h"
+#include "minunit.h"
+#include "rng.h"
 #include "scs.h"
+#include "scs_matrix.h"
 #include "util.h"
 
-#define PI (3.141592654)
-#ifdef DLONG
-#ifdef _WIN64
-/* this is a Microsoft extension, but also works with min_g_w-w64 */
-#define INTRW "%I64d"
-#else
-#define INTRW "%ld"
-#endif
-#else
-#define INTRW "%i"
-#endif
-
-void gen_random_prob_data(scs_int nnz, scs_int col_nnz, ScsData *d, ScsCone *k,
-                          ScsSolution *opt_sol);
+#define _MAX_RAND_VAL (1073741823) /* 2^30 - 1 */
 
 /* uniform random number in [-1,1] */
 static scs_float rand_scs_float(void) {
-  return 2 * (((scs_float)rand()) / RAND_MAX) - 1;
+  return 2 * (((scs_float)ran_arr_next()) / _MAX_RAND_VAL) - 1; /* in [-1, 1] */
 }
 
 void gen_random_prob_data(scs_int nnz, scs_int col_nnz, ScsData *d, ScsCone *k,
-                          ScsSolution *opt_sol) {
+                          ScsSolution *opt_sol, scs_int seed) {
   scs_int n = d->n;
   scs_int m = d->m;
   ScsMatrix *A = d->A = (ScsMatrix *)scs_calloc(1, sizeof(ScsMatrix));
@@ -39,6 +29,7 @@ void gen_random_prob_data(scs_int nnz, scs_int col_nnz, ScsData *d, ScsCone *k,
   scs_float *s = opt_sol->s = (scs_float *)scs_calloc(m, sizeof(scs_float));
   /* temporary variables */
   scs_float *z = (scs_float *)scs_calloc(m, sizeof(scs_float));
+  ScsConeWork *tmp_cone_work;
   scs_int i, j, r, rn, rm;
 
   A->i = (scs_int *)scs_calloc(nnz, sizeof(scs_int));
@@ -50,8 +41,9 @@ void gen_random_prob_data(scs_int nnz, scs_int col_nnz, ScsData *d, ScsCone *k,
   for (i = 0; i < m; i++) {
     y[i] = z[i] = rand_scs_float();
   }
-
-  SCS(proj_dual_cone)(y, k, SCS_NULL, SCS_NULL, -1);
+  tmp_cone_work = SCS(init_cone)(k, m);
+  SCS(proj_dual_cone)(y, tmp_cone_work, SCS_NULL, SCS_NULL);
+  SCS(finish_cone(tmp_cone_work));
 
   for (i = 0; i < m; i++) {
     b[i] = s[i] = y[i] - z[i];
@@ -65,18 +57,15 @@ void gen_random_prob_data(scs_int nnz, scs_int col_nnz, ScsData *d, ScsCone *k,
    c = -A'*y
    b = A*x + s
    */
+  ran_start(seed);
   A->p[0] = 0;
-  scs_printf("Generating random matrix:\n");
   for (j = 0; j < n; j++) { /* column */
-    if (j * 100 % n == 0 && (j * 100 / n) % 10 == 0) {
-      scs_printf("%ld%%\n", (long)(j * 100 / n));
-    }
     r = 0;
     for (i = 0; i < m && r < col_nnz; ++i) {
       /* generate a unique sorted array via Knuths alg */
       rn = m - i;
       rm = col_nnz - r;
-      if ((rand() % rn) < rm) {
+      if ((ran_arr_next() % rn) < rm) {
         A->x[r + j * col_nnz] = rand_scs_float();
         A->i[r + j * col_nnz] = i;
         b[i] += A->x[r + j * col_nnz] * x[j];
@@ -86,8 +75,174 @@ void gen_random_prob_data(scs_int nnz, scs_int col_nnz, ScsData *d, ScsCone *k,
     }
     A->p[j + 1] = (j + 1) * col_nnz;
   }
-  scs_printf("done\n");
   scs_free(z);
 }
 
+static scs_float get_dual_cone_dist(const scs_float *y, ScsConeWork *c,
+                                    scs_int m) {
+  scs_float dist;
+  scs_float *t = (scs_float *)scs_calloc(m, sizeof(scs_float));
+  memcpy(t, y, m * sizeof(scs_float));
+  SCS(proj_dual_cone)(t, c, SCS_NULL, SCS_NULL);
+  dist = SCS(norm_inf_diff)(t, y, m);
+  scs_free(t);
+  return dist;
+}
+
+/* via moreau */
+static scs_float get_pri_cone_dist(const scs_float *s, ScsConeWork *c,
+                                   scs_int m) {
+  scs_float dist;
+  scs_float *t = (scs_float *)scs_calloc(m, sizeof(scs_float));
+  memcpy(t, s, m * sizeof(scs_float));
+  SCS(scale_array)(t, -1.0, m);
+  SCS(proj_dual_cone)(t, c, SCS_NULL, SCS_NULL);
+  dist = SCS(norm_inf)(t, m); /* ||s - Pi_c(s)|| = ||Pi_c*(-s)|| */
+  scs_free(t);
+  return dist;
+}
+
+const char *verify_solution_correct(ScsData *d, ScsCone *k, ScsSettings *stgs,
+                                    ScsInfo *info, ScsSolution *sol,
+                                    scs_int status) {
+  scs_int n = d->n, m = d->m;
+  scs_float *x = sol->x;
+  scs_float *y = sol->y;
+  scs_float *s = sol->s;
+
+  scs_float *c = d->c;
+  scs_float *b = d->b;
+
+  scs_float *primal = (scs_float *)scs_calloc(m, sizeof(scs_float));
+  scs_float *ax = (scs_float *)scs_calloc(m, sizeof(scs_float));
+  scs_float *dual = (scs_float *)scs_calloc(n, sizeof(scs_float));
+  scs_float *px = (scs_float *)scs_calloc(n, sizeof(scs_float));
+  scs_float *aty = (scs_float *)scs_calloc(n, sizeof(scs_float));
+
+  scs_float res_pri, res_dual, res_infeas, res_unbdd_a, res_unbdd_p;
+  scs_float ctx, bty, xt_p_x, gap, pobj, dobj, sty;
+  scs_float grl, prl, drl;
+
+  scs_float sdist = NAN, ydist = NAN;
+
+  ScsConeWork *cone_work = SCS(init_cone)(k, m);
+
+  /**************** PRIMAL *********************/
+  memset(ax, 0, m * sizeof(scs_float));
+  /* Ax */
+  SCS(accum_by_a)(d->A, x, ax);
+
+  memcpy(primal, ax, m * sizeof(scs_float));
+  /* Ax + s */
+  SCS(add_scaled_array)(primal, s, m, 1.);
+
+  /* unbounded residual |Ax + s| */
+  res_unbdd_a = NORM(primal, m);
+
+  /* Ax + s - b */
+  SCS(add_scaled_array)(primal, b, m, -1.0);
+
+  res_pri = NORM(primal, m);
+
+  /**************** DUAL *********************/
+  memset(px, 0, n * sizeof(scs_float));
+  if (d->P) {
+    /* px = Px */
+    SCS(accum_by_p)(d->P, x, px);
+    xt_p_x = SCS(dot)(px, x, n);
+    res_unbdd_p = NORM(px, n);
+  } else {
+    xt_p_x = 0;
+    res_unbdd_p = 0;
+  }
+
+  memset(aty, 0, n * sizeof(scs_float));
+  /* aty = A'y */
+  SCS(accum_by_atrans)(d->A, y, aty);
+  res_infeas = NORM(aty, n);
+
+  memcpy(dual, aty, n * sizeof(scs_float));
+  /* Px + A'y */
+  SCS(add_scaled_array)(dual, px, n, 1.);
+  /* Px + A'y + c */
+  SCS(add_scaled_array)(dual, c, n, 1.0);
+
+  res_dual = NORM(dual, n);
+
+  /**************** CONES *****************/
+
+  if (status == SCS_SOLVED || status == SCS_UNBOUNDED) {
+    sdist = get_pri_cone_dist(sol->s, cone_work, m);
+  }
+  if (status == SCS_SOLVED || status == SCS_INFEASIBLE) {
+    ydist = get_dual_cone_dist(sol->y, cone_work, m);
+  }
+
+  /**************** OTHERS *****************/
+  sty = SCS(dot)(y, s, m);
+
+  bty = SCS(dot)(y, b, m);
+  ctx = SCS(dot)(x, c, n);
+
+  gap = ABS(xt_p_x + ctx + bty);
+  pobj = xt_p_x / 2. + ctx;
+  dobj = -xt_p_x / 2. - bty;
+
+  /************** OPTIMALITY ****************/
+
+  grl = MAX(MAX(ABS(xt_p_x), ABS(ctx)), ABS(bty));
+  prl = MAX(MAX(NORM(b, m), NORM(s, m)), NORM(ax, m));
+  drl = MAX(MAX(NORM(c, n), NORM(px, n)), NORM(aty, n));
+
+  /**************** CLEANUP *****************/
+  scs_free(primal);
+  scs_free(dual);
+  scs_free(px);
+  scs_free(ax);
+  scs_free(aty);
+  SCS(finish_cone)(cone_work);
+
+  /**************** ASSERTS *****************/
+  if (status == SCS_SOLVED) {
+    mu_assert_less("Primal residual ERROR", ABS(res_pri - info->res_pri),
+                   1e-11);
+    mu_assert_less("Dual residual ERROR", ABS(res_dual - info->res_dual),
+                   1e-11);
+    mu_assert_less("Gap ERROR", ABS(gap - info->gap), 1e-8 * (1 + ABS(gap)));
+    mu_assert_less("Primal obj ERROR", ABS(pobj - info->pobj),
+                   1e-9 * (1 + ABS(pobj)));
+    mu_assert_less("Dual obj ERROR", ABS(dobj - info->dobj),
+                   1e-9 * (1 + ABS(dobj)));
+    /* slightly looser tol */
+    mu_assert_less("Complementary slackness ERROR", ABS(sty),
+                   1e-8 * MAX(NORM(s, m), NORM(y, m)));
+    mu_assert_less("s cone dist ERROR", ABS(sdist), 1e-5);
+    mu_assert_less("y cone dist ERROR", ABS(ydist), 1e-5);
+
+    mu_assert_less("Primal feas ERROR", res_pri,
+                   stgs->eps_abs + stgs->eps_rel * prl);
+    mu_assert_less("Dual feas ERROR", res_dual,
+                   stgs->eps_abs + stgs->eps_rel * drl);
+    mu_assert_less("Gap feas ERROR", gap, stgs->eps_abs + stgs->eps_rel * grl);
+
+  } else if (status == SCS_INFEASIBLE) {
+    mu_assert_less("Infeas ERROR", ABS(res_infeas - info->res_infeas), 1e-8);
+    mu_assert_less("bty ERROR", ABS(bty + 1), 1e-12);
+    mu_assert_less("y cone dist ERROR", ABS(ydist), 1e-5);
+    mu_assert_less("Infeas invalid ERROR", res_infeas, stgs->eps_infeas);
+
+  } else if (status == SCS_UNBOUNDED) {
+    mu_assert_less("Unbdd_a ERROR", ABS(res_unbdd_a - info->res_unbdd_a), 1e-8);
+    mu_assert_less("Unbdd_p ERROR", ABS(res_unbdd_p - info->res_unbdd_p), 1e-8);
+    mu_assert_less("ctx ERROR", ABS(ctx + 1), 1e-12);
+    mu_assert_less("s cone dist ERROR", ABS(sdist), 1e-5);
+    mu_assert_less("Unbounded P invalid ERROR", res_unbdd_p, stgs->eps_infeas);
+    mu_assert_less("Unbounded A invalid ERROR", res_unbdd_a, stgs->eps_infeas);
+
+  } else {
+    return "INVALID STATUS";
+  }
+  return 0;
+}
+
 #endif

data/vendor/scs/test/problems/degenerate.h

@@ -0,0 +1,130 @@
+#include "glbopts.h"
+#include "linalg.h"
+#include "minunit.h"
+#include "scs.h"
+#include "scs_matrix.h"
+#include "util.h"
+
+/* test degenerate cones */
+static const char *degenerate(void) {
+  ScsCone *k = (ScsCone *)scs_calloc(1, sizeof(ScsCone));
+  ScsData *d = (ScsData *)scs_calloc(1, sizeof(ScsData));
+  ScsSettings *stgs = (ScsSettings *)scs_calloc(1, sizeof(ScsSettings));
+  ScsSolution *sol = (ScsSolution *)scs_calloc(1, sizeof(ScsSolution));
+  ScsInfo info = {0};
+  scs_int exitflag, success;
+  scs_float tpobj, tdobj, perr, derr;
+  const char *fail;
+
+  /* data */
+  scs_float Ax[] = {-10., -1., 1., -1.};
+  scs_int Ai[] = {1, 2, 1, 3};
+  scs_int Ap[] = {0, 2, 4};
+
+  scs_float Px[] = {0.02, 2.};
+  scs_int Pi[] = {0, 1};
+  scs_int Pp[] = {0, 1, 2};
+
+  scs_float b[] = {1., -1., 2., -0.5};
+  scs_float c[] = {1., 2.};
+
+  scs_int m = 4;
+  scs_int n = 2;
+
+  /* used later: */
+  scs_int sq[] = {1};
+
+  /* end data */
+
+  d->m = m;
+  d->n = n;
+  d->b = b;
+  d->c = c;
+
+  d->A = (ScsMatrix *)scs_calloc(1, sizeof(ScsMatrix));
+  d->P = (ScsMatrix *)scs_calloc(1, sizeof(ScsMatrix));
+
+  d->A->m = m;
+  d->A->n = n;
+
+  d->A->x = Ax;
+  d->A->i = Ai;
+  d->A->p = Ap;
+
+  d->P->m = n;
+  d->P->n = n;
+
+  d->P->x = Px;
+  d->P->i = Pi;
+  d->P->p = Pp;
+
+  scs_set_default_settings(stgs);
+  stgs->eps_abs = 1e-6;
+  stgs->eps_rel = 1e-6;
+  stgs->eps_infeas = 1e-9;
+
+  /* positive orthants */
+  k->l = 4;
+  exitflag = scs(d, k, stgs, sol, &info);
+  fail = verify_solution_correct(d, k, stgs, &info, sol, exitflag);
+  if (fail) {
+    return fail;
+  }
+  mu_assert("bsize: SCS failed to produce outputflag SCS_SOLVED",
+            exitflag == SCS_SOLVED);
+
+  tpobj = info.pobj;
+  tdobj = info.dobj;
+
+  /* degenerate box cone */
+  k->bsize = 1;
+  k->l = 3;
+  exitflag = scs(d, k, stgs, sol, &info);
+  fail = verify_solution_correct(d, k, stgs, &info, sol, exitflag);
+  if (fail) {
+    return fail;
+  }
+  perr = info.pobj - tpobj;
+  derr = info.dobj - tdobj;
+  success = ABS(perr) < 1e-8 && ABS(derr) < 1e-8 && exitflag == SCS_SOLVED;
+  mu_assert("degenerate box cone failure", success);
+
+  /* degenerate SOC cone */
+  k->bsize = 0;
+  k->q = sq;
+  k->qsize = 1;
+  k->l = 3;
+  exitflag = scs(d, k, stgs, sol, &info);
+  fail = verify_solution_correct(d, k, stgs, &info, sol, exitflag);
+  if (fail) {
+    return fail;
+  }
+  perr = info.pobj - tpobj;
+  derr = info.dobj - tdobj;
+  success = ABS(perr) < 1e-8 && ABS(derr) < 1e-8 && exitflag == SCS_SOLVED;
+  mu_assert("degenerate SOC cone failure", success);
+
+  /* degenerate PSD cone */
+  k->q = 0;
+  k->qsize = 0;
+  k->s = sq;
+  k->ssize = 1;
+  k->l = 3;
+  exitflag = scs(d, k, stgs, sol, &info);
+  fail = verify_solution_correct(d, k, stgs, &info, sol, exitflag);
+  if (fail) {
+    return fail;
+  }
+  perr = info.pobj - tpobj;
+  derr = info.dobj - tdobj;
+  success = ABS(perr) < 1e-8 && ABS(derr) < 1e-8 && exitflag == SCS_SOLVED;
+  mu_assert("degenerate PSD cone failure", success);
+
+  SCS(free_sol)(sol);
+  scs_free(d->A);
+  scs_free(d->P);
+  scs_free(k);
+  scs_free(stgs);
+  scs_free(d);
+  return fail;
+}