scs 0.5.0 → 0.5.2

data/vendor/scs/src/spectral_cones/logdeterminant/log_cone_Newton.c

@@ -0,0 +1,279 @@
+#include "glbopts.h" // for scs_printf
+#include "linalg.h"
+#include "scs_blas.h"
+#include "util_spectral_cones.h"
+#include <string.h> // for memcpy
+
+/*
+ * Spectral matrix cone projections, from "Projection onto Spectral Matrix
+ * Cones" by Daniel Cederberg and Stephen Boyd, 2024.
+ *
+ * If you have any questions on the code, please reach out to the code author
+ * Daniel Cederberg.
+ *
+ * This file implements Newton's method for projecting onto the logarithmic
+ * cone.
+ *
+ * Last modified: 25 August 2024.
+ */
+
+#define LINESEARCH_RELATIVE_TOL 1e-14
+#define MIN_INIT_LOG_CONE 1
+#define MIN_DENOMINATOR 1e-14
+#define MIN_X 1e-17
+#define MIN_FLOAT MIN_X / 2
+#define MIN_V 1e-14
+
+#define MAX_ITER_NEWTON 100
+#define ALPHA_NEWTON 0.01
+#define BETA_NEWTON 0.8
+#define TOL_NEWTON 1e-12
+#define MAX_GRAD_STEPS 5
+
+#define TERMINATE_DUE_TO_ZEROS -5
+#define MAX_GRAD_STEPS_REACHED -6
+
+// the CALLER of this function must make sure that the arguments belong to the
+// domain
+static scs_float obj_val(const scs_float *u, scs_float t0, scs_float v0,
+                         const scs_float *x0, scs_int n) {
+  scs_float v = u[0];
+  const scs_float *x = u + 1;
+
+  assert(v > 0 && min_vec(x, n) > 0);
+
+  scs_float sx = -(v * sum_log(x, n) - n * v * log(v));
+  scs_float obj = 0.5 * (sx - t0) * (sx - t0) + 0.5 * (v - v0) * (v - v0);
+  for (scs_int i = 0; i < n; ++i) {
+    obj += 0.5 * (x[i] - x0[i]) * (x[i] - x0[i]);
+  }
+  return obj;
+}
+
+scs_int log_cone_Newton(scs_float t0, scs_float v0, const scs_float *x0,
+                        scs_float *u, scs_int n, scs_float *workspace,
+                        Newton_stats *stats, bool *warm_start) {
+  scs_float *t = u;
+  scs_float *v = u + 1;
+  scs_float *x = u + 2;
+  scs_int n_plus_one = n + 1;
+
+  // -------------------------------------------------------------------------
+  //     check cone membership and special cases with analytic projections
+  // -------------------------------------------------------------------------
+  bool ix_x0_non_neg = true;
+  bool is_x0_pos = true;
+  scs_int i = 0;
+  while (ix_x0_non_neg || is_x0_pos) {
+    if (x[i] < 0) {
+      ix_x0_non_neg = false;
+      is_x0_pos = false;
+    } else if (x[i] == 0) {
+      is_x0_pos = false;
+    }
+
+    if (i == n - 1) {
+      break;
+    }
+    ++i;
+  }
+
+  // if (t0, v0, x0) belongs to cone
+  if ((v0 > 0 && is_x0_pos && -v0 * (sum_log(x0, n) - n * log(v0)) <= t0) ||
+      (v0 == 0 && ix_x0_non_neg && t0 >= 0)) {
+    *t = t0;
+    *v = v0;
+    memcpy(x, x0, sizeof(*x0) * n);
+    stats->iter = IN_CONE;
+    *warm_start = true;
+    return 0;
+  }
+
+  // if (t0, v0, x0) belongs to negative dual cone
+  if (t0 < 0 && is_negative(x0, n)) {
+    scs_float sum = -n;
+    for (i = 0; i < n; ++i) {
+      sum -= log(x0[i] / t0);
+    }
+    sum *= t0;
+
+    if (v0 <= sum) {
+      memset(u, 0, (n + 2) * sizeof(*x0));
+      stats->iter = IN_NEGATIVE_DUAL_CONE;
+      // if 0 is the solution we should not use it to warmstart the next
+      // iteration
+      *warm_start = false;
+      return 0;
+    }
+  }
+
+  // special case with analytic solution
+  if (v0 <= 0 && t0 >= 0) {
+    *t = t0;
+    *v = 0;
+    non_neg_proj(x0, x, n);
+    stats->iter = ANALYTICAL_SOL;
+    *warm_start = true;
+    return 0;
+  }
+
+  // ----------------------------------------------------------------------
+  // if 'warm_start' is false we initialize in the point
+  // (v, x) = (max(v0, MIN_INIT_LOG_CONE), max(x0, MIN_INIT_LOG_CONE)),
+  // otherwise it is assumed that 'proj' has already been
+  // initialized / warmstarted.
+  // ----------------------------------------------------------------------
+  if (!(*warm_start)) {
+    *v = (v0 > MIN_INIT_LOG_CONE) ? v0 : MIN_INIT_LOG_CONE;
+
+    for (scs_int i = 0; i < n; ++i) {
+      x[i] = (x0[i] > MIN_INIT_LOG_CONE) ? x0[i] : MIN_INIT_LOG_CONE;
+    }
+  }
+
+  scs_float obj_old = obj_val(u + 1, t0, v0, x0, n);
+
+  // -----------------------------
+  //      parse workspace
+  // -----------------------------
+  scs_float *grad = workspace;
+  scs_float *d = grad + n_plus_one;
+  scs_float *w = d + n_plus_one;
+  scs_float *du = w + n_plus_one;
+  scs_float *temp1 = du + n_plus_one;
+  scs_float *u_new = du + n_plus_one + 1;
+
+  size_t num_grad_steps = 0;
+  scs_int iter = 0;
+  scs_float newton_decrement = 0;
+  for (iter = 1; iter <= MAX_ITER_NEWTON; ++iter) {
+    // A small value on v indicates that Newton's method converges to the
+    // origin. In this case we should abort and apply an IPM.
+    if (*v < MIN_V) {
+      stats->iter = TERMINATE_DUE_TO_ZEROS;
+      return -1;
+    }
+
+    // -------------------------------------------------------------------
+    // To avoid pathological cases where some components of
+    // x approach 0 we use a minimum threshold.
+    // -------------------------------------------------------------------
+    for (scs_int i = 0; i < n; i++) {
+      x[i] = MAX(x[i], MIN_X);
+    }
+
+    // ----------------------------------------------------------------
+    //                  compute gradient and Hessian
+    // ----------------------------------------------------------------
+    assert(*v > MIN_FLOAT && min_vec(x, n) > MIN_FLOAT);
+    scs_float temp0 = -sum_log(x, n) + n * log(*v);
+    scs_float a = (*v) * temp0 - t0;
+    scs_float c = temp0 + n;
+
+    grad[0] = a * c + (*v) - v0;
+    scs_float v_inv = 1 / (*v);
+    d[0] = 1 + a * (-a * (v_inv * v_inv) + n * v_inv - 2 * c * v_inv);
+    w[0] = -(a + (*v) * c) * v_inv;
+    scs_float av = a * (*v);
+
+    for (i = 1; i < n + 1; ++i) {
+      assert(x[i - 1] > 0);
+      scs_float x_inv = 1 / x[i - 1];
+      grad[i] = -av * x_inv + x[i - 1] - x0[i - 1];
+      d[i] = 1 + av * (x_inv * x_inv);
+      w[i] = (*v) * x_inv;
+    }
+
+    // ----------------------------------------------------------------------
+    //    Solve for Newton step. I have seen a scenario when the variable
+    //   'denominator' becomes 0. This occurred when Newton's method
+    //    converged to the origin and the IPM was necessary
+    //    to converge to the correct point. We therefore abort when the
+    //    denominator becomes very close to 0, since this may indicate
+    //    that Newton's method is converging to the wrong point and in this
+    //    case it is necessary to apply an IPM.
+    // ----------------------------------------------------------------------
+    scs_float nominator = 0;
+    scs_float denominator = 1;
+    for (i = 0; i < n + 1; ++i) {
+      assert(fabs(d[i]) > MIN_FLOAT);
+      du[i] = -grad[i] / d[i];
+      nominator += w[i] * du[i];
+      temp1[i] = w[i] / d[i];
+      denominator += w[i] * temp1[i];
+    }
+
+    if (fabs(denominator) < MIN_DENOMINATOR) {
+      stats->iter = TERMINATE_DUE_TO_ZEROS;
+      return -1;
+    }
+
+    scs_float ratio = -nominator / denominator;
+    SCS(add_scaled_array)(du, temp1, n_plus_one, ratio);
+
+    // --------------------------------------------------------------------
+    // if the Newton direction is not descent we use the negative gradient
+    // as the search direction, provided that it hasn't been used many times
+    // before.
+    // --------------------------------------------------------------------
+    scs_float dirDer = SCS(dot)(grad, du, n_plus_one);
+    if (dirDer > 0) {
+      if (num_grad_steps >= MAX_GRAD_STEPS) {
+        stats->iter = MAX_GRAD_STEPS_REACHED;
+        return -1;
+      }
+
+      num_grad_steps += 1;
+      dirDer = 0;
+
+      for (i = 0; i < n + 1; ++i) {
+        du[i] = -grad[i];
+        dirDer -= grad[i] * grad[i];
+      }
+    }
+
+    // --------------------------------------------------------
+    // compute Newton decrement and check termination criteria
+    // -------------------------------------------------------
+    newton_decrement = -dirDer;
+    if (newton_decrement <= 2 * TOL_NEWTON) {
+      break;
+    }
+
+    // --------------------------------------------------
+    // find largest step size with respect to the domain
+    // --------------------------------------------------
+    scs_float step_size = 1;
+    for (i = 0; i < n + 1; i++) {
+      if (du[i] < 0) {
+        scs_float max_step = -0.99 * u[i + 1] / du[i];
+        step_size = MIN(step_size, max_step);
+      }
+    }
+
+    // -------------------------------------------------
+    // backtracking line search. First two lines do
+    // u_new = u + t * du;
+    // -------------------------------------------------
+    memcpy(u_new + 1, u + 1, n_plus_one * sizeof(*u));
+    SCS(add_scaled_array)(u_new + 1, du, n_plus_one, step_size);
+    scs_float new_obj = obj_val(u_new + 1, t0, v0, x0, n);
+    while ((1 - LINESEARCH_RELATIVE_TOL) * new_obj >
+           obj_old + ALPHA_NEWTON * step_size * dirDer) {
+      step_size *= BETA_NEWTON;
+      memcpy(u_new + 1, u + 1, n_plus_one * sizeof(*u));
+      SCS(add_scaled_array)(u_new + 1, du, n_plus_one, step_size);
+      new_obj = obj_val(u_new + 1, t0, v0, x0, n);
+    }
+
+    obj_old = new_obj;
+    memcpy(u + 1, u_new + 1, n_plus_one * sizeof(*u));
+  }
+
+  assert(min_vec(x, n) > MIN_FLOAT && *v > MIN_FLOAT);
+  *t = -(*v) * (sum_log(x, n) - n * log(*v));
+
+  *warm_start = true;
+  stats->iter = iter;
+  return 0;
+}

data/vendor/scs/src/spectral_cones/logdeterminant/log_cone_wrapper.c

@@ -0,0 +1,205 @@
+#include "cones.h"
+#include "glbopts.h"
+#include "linalg.h"
+#include "scs.h"
+#include "scs_blas.h"
+#include "util_spectral_cones.h"
+
+#define DUAL_FEAS_TOL 1e-2
+#define PRI_FEAS_TOL 1e-2
+#define COMP_TOL 1e-2
+#define DUAL_T_THRESHOLD 1e-8
+#define DUAL_X_THRESHOLD 1e-8
+
+#define NEWTON_SUCCESS 1
+#define IPM_VARIANT_0_SUCCESS 2
+#define IPM_VARIANT_1_SUCCESS 3
+
+/*
+ * Spectral matrix cone projections, from "Projection onto Spectral Matrix
+ * Cones" by Daniel Cederberg and Stephen Boyd, 2024.
+ *
+ * If you have any questions on the code, please reach out to the code author
+ * Daniel Cederberg.
+ *
+ * This file implements a wrapper to the code that projects onto the logarithmic
+ * cone.
+ *
+ * Last modified: 25 August 2024.
+ */
+
+// forward declare from log_cone_Newton.c
+scs_int log_cone_Newton(scs_float t0, scs_float v0, const scs_float *x0,
+                        scs_float *proj, scs_int n, scs_float *workspace,
+                        Newton_stats *stats, bool *warm_start);
+
+// forward declare form log_cone_IPM.c
+scs_int log_cone_IPM(scs_float t0, scs_float v0, scs_float *x0, scs_float *u1,
+                     scs_int n, scs_float *workspace, Newton_stats *stats,
+                     scs_int variant);
+
+// forward declare from this file
+static void check_opt_cond_log_cone(const scs_float *tvx, scs_float t0,
+                                    scs_float v0, const scs_float *x0,
+                                    scs_int n, scs_float residuals[3],
+                                    scs_float *dualx);
+
+scs_int log_cone_proj_wrapper(scs_float t0, scs_float v0, scs_float *x0,
+                              scs_float *proj, scs_int n, scs_float *workspace,
+                              Newton_stats *stats, bool *warm_start) {
+  scs_int status;
+  // -----------------------------------------------------------------------
+  // 1. Solve problem with Newton's method. From Lagrange multiplier theory
+  //    we know that the t-component of the projection must always be greater
+  //    than t0, so if proj[0] < t0 it means that Newton's method has converged
+  //    to wrong point. We return if proj[0] >= t0 and the residuals suggest
+  //    that we converged to the correct point.
+  // 2. We warmstart Newton using the solution of the previous iteration
+  //    except for the first iteration.
+  // 3. The current implementation of the warmstart assumes that there is only
+  //    one spectral matrix cone so 'proj' isn't overwritten.
+  // ------------------------------------------------------------------------
+  status = log_cone_Newton(t0, v0, x0, proj, n, workspace, stats, warm_start);
+
+  if (proj[0] >= t0 - 0.1 * fabs(t0)) {
+    check_opt_cond_log_cone(proj, t0, v0, x0, n, stats->residuals, workspace);
+  } else {
+    status = -1;
+  }
+
+  if (status == 0 && stats->residuals[0] < DUAL_FEAS_TOL &&
+      stats->residuals[1] < PRI_FEAS_TOL &&
+      fabs(stats->residuals[2]) < COMP_TOL) {
+    stats->newton_success = NEWTON_SUCCESS;
+    return 0;
+  }
+
+  // ------------------------------------------------------------------------
+  // Solve problem with primal-dual IPM incorporating Mehrotra's correction
+  // etc.
+  // ------------------------------------------------------------------------
+  status = log_cone_IPM(t0, v0, x0, proj, n, workspace, stats, 0);
+  check_opt_cond_log_cone(proj, t0, v0, x0, n, stats->residuals, workspace);
+
+  *warm_start = true; // next iteration Newton should be warmstarted
+
+  if (status == 0 && stats->residuals[0] < DUAL_FEAS_TOL &&
+      stats->residuals[1] < PRI_FEAS_TOL &&
+      fabs(stats->residuals[2]) < COMP_TOL) {
+    stats->newton_success = IPM_VARIANT_0_SUCCESS;
+    return 0;
+  }
+
+  // ------------------------------------------------------------------------
+  // Solve problem with primal-dual IPM without Mehrotra's correction
+  // etc. (In all experiments in the paper by Cederberg and Boyd,
+  // the IPM above solves the problem correctly so the code below never
+  // runs. However, during development I ran into a (possibly pathological
+  // case) where the first IPM fails. If this happens we run below another
+  // version. This version of the IPM solves the problem that the first version
+  // failed on.)
+  // ------------------------------------------------------------------------
+  status = log_cone_IPM(t0, v0, x0, proj, n, workspace, stats, 1);
+  check_opt_cond_log_cone(proj, t0, v0, x0, n, stats->residuals, workspace);
+
+  if (status == 0 && stats->residuals[0] < DUAL_FEAS_TOL &&
+      stats->residuals[1] < PRI_FEAS_TOL &&
+      fabs(stats->residuals[2]) < COMP_TOL) {
+    stats->newton_success = IPM_VARIANT_1_SUCCESS;
+    return 0;
+  }
+
+#ifdef SPECTRAL_DEBUG
+  scs_printf("FAILURE: logarithmic cone projection");
+  scs_printf("dual_res / pri_res / comp / iter: %.3e, %.3e, %.3e, %d\n",
+             stats->residuals[0], stats->residuals[1], stats->residuals[2],
+             stats->iter);
+
+  scs_printf("Projecting the following point:\n %.10e, %.10e", t0, v0);
+  for (scs_int i = 0; i < n; i++) {
+    scs_printf(" %.10e", x0[i]);
+  }
+  scs_printf("\n");
+#endif
+
+  return -1;
+}
+
+// tvx = [t, v, x].
+static void check_opt_cond_log_cone(const scs_float *tvx, scs_float t0,
+                                    scs_float v0, const scs_float *x0,
+                                    scs_int n, scs_float residuals[3],
+                                    scs_float *dualx) {
+  scs_float pri_res, dual_res, complementarity;
+
+  // -------------------------------------------------------
+  //           Compute Lagrange multiplier
+  // -------------------------------------------------------
+  scs_float dualt = tvx[0] - t0;
+  if (fabs(dualt) < DUAL_T_THRESHOLD) {
+    dualt = DUAL_T_THRESHOLD;
+  }
+  scs_float dualv = tvx[1] - v0;
+  for (scs_int i = 0; i < n; ++i) {
+    dualx[i] = tvx[i + 2] - x0[i];
+    if (fabs(dualx[i]) < DUAL_X_THRESHOLD) {
+      dualx[i] = DUAL_X_THRESHOLD;
+    }
+  }
+
+  // ---------------------------------------------------------------------
+  //          Compute complementarity measure
+  // ---------------------------------------------------------------------
+  complementarity =
+      tvx[0] * dualt + tvx[1] * dualv + SCS(dot)(dualx, tvx + 2, n);
+
+  // ----------------------------------------------------------------------
+  //          Compute primal feasibility measure
+  // ----------------------------------------------------------------------
+  if (tvx[1] > 0 && is_pos(tvx + 2, n)) {
+    pri_res = -tvx[1] * (sum_log(tvx + 2, n) - n * log(tvx[1])) - tvx[0];
+  } else {
+    pri_res = tvx[1] * tvx[1];
+
+    if (tvx[0] < 0) {
+      pri_res += tvx[0] * tvx[0];
+    }
+
+    for (const scs_float *xi = tvx + 2; xi < tvx + 2 + n; ++xi) {
+      if (*xi < 0) {
+        pri_res += (*xi) * (*xi);
+      }
+    }
+  }
+
+  // ----------------------------------------------------------------------
+  //          Compute dual feasibility measure
+  // ----------------------------------------------------------------------
+  if (dualt > 0 && is_pos(dualx, n)) {
+    dual_res = dualt * (n * log(dualt) - n - sum_log(dualx, n)) - dualv;
+  } else {
+    dual_res = dualt * dualt;
+
+    if (dualv < 0) {
+      dual_res += dualv * dualv;
+    }
+
+    for (scs_int i = 0; i < n; i++) {
+      if (dualx[i] < 0) {
+        dual_res += dualx[i] * dualx[i];
+      }
+    }
+  }
+
+  // --------------------------------------------------------
+  //    Normalize the residuals and assign the result
+  // --------------------------------------------------------
+  scs_float dual_norm =
+      sqrt(dualt * dualt + dualv * dualv + SCS(norm_sq)(dualx, n));
+  scs_float pri_norm = SCS(norm_2)(tvx, n + 2);
+  residuals[0] = dual_res / MAX(dual_norm, 1.0);
+  residuals[1] = pri_res / MAX(pri_norm, 1.0);
+  double scale = MAX(pri_norm, 1.0);
+  residuals[2] = complementarity / MAX(scale, dual_norm);
+}
+

data/vendor/scs/src/spectral_cones/logdeterminant/logdet_cone.c

@@ -0,0 +1,143 @@
+#include "cones.h"
+#include "glbopts.h"
+#include "linalg.h"
+#include "scs.h"
+#include "scs_blas.h"
+#include "util.h"
+#include "util_spectral_cones.h"
+
+/*
+ * Spectral matrix cone projections, from "Projection onto Spectral Matrix
+ * Cones" by Daniel Cederberg and Stephen Boyd, 2024.
+ *
+ * If you have any questions on the code, please reach out to the code author
+ * Daniel Cederberg.
+ *
+ * This file implements the projection onto the log-determinant cone.
+ *
+ * Last modified: 25 August 2024.
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void BLAS(syev)(const char *jobz, const char *uplo, blas_int *n, scs_float *a,
+                blas_int *lda, scs_float *w, scs_float *work, blas_int *lwork,
+                blas_int *info);
+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);
+void BLAS(scal)(const blas_int *n, const scs_float *sa, scs_float *sx,
+                const blas_int *incx);
+
+#ifdef __cplusplus
+}
+#endif
+
+// forward declare from log_cone_wrapper.c
+scs_int log_cone_proj_wrapper(scs_float t0, scs_float v0, scs_float *x0,
+                              scs_float *proj, scs_int n, scs_float *workspace,
+                              Newton_stats *stats, bool *warm_start);
+
+scs_int SCS(proj_logdet_cone)(scs_float *tvX, scs_int n, ScsConeWork *c,
+                              scs_int offset, bool *warmstart) {
+  Newton_stats *stats = &(c->newton_stats);
+
+  // tvX = [t, v, X], where X represents the lower triangular part of a matrix
+  // stored in a compact form and off-diagonal elements have been scaled by
+  // sqrt(2)
+  scs_float *X = tvX + 2;
+
+#ifndef USE_LAPACK
+  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);
+  return -1;
+#endif
+
+  // ----------------------------------------------------------------------
+  //                      compute eigendecomposition
+  // ----------------------------------------------------------------------
+  scs_int i;
+  blas_int nb = (blas_int)n;
+  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;
+
+  // copy lower triangular matrix into full matrix
+  for (i = 0; i < n; ++i) {
+    memcpy(&(Xs[i * (n + 1)]), &(X[i * n - ((i - 1) * i) / 2]),
+           (n - i) * sizeof(scs_float));
+  }
+
+  // rescale diags by sqrt(2)
+  BLAS(scal)(&nb, &sqrt2, Xs, &nb_plus_one);
+
+  // Eigendecomposition. On exit, the lower triangular part of Xs stores
+  // the eigenvectors. The vector e stores the eigenvalues in ascending
+  // order (smallest eigenvalue first) */
+  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) {
+      scs_printf("entering LAPACK stuff!\n");
+      return info;
+    }
+  }
+
+  // ----------------------------------------------------------------------
+  //  Project onto spectral *vector* cone. Note that e is sqrt(2) times
+  //  the eigenvalue vector we want to project. We therefore multiply
+  //  tvX[0] and tvX[1] by sqrt(2). The projection of sqrt(2) * (t0, v0,
+  //  evals) is stored in current_log_proj
+  // (or equivalently, in c->saved_log_projs + offset)
+  // ----------------------------------------------------------------------
+  scs_float *current_log_proj = c->saved_log_projs + offset;
+  SPECTRAL_TIMING(SCS(timer) _timer; SCS(tic)(&_timer);)
+  scs_int status =
+      log_cone_proj_wrapper(sqrt2 * tvX[0], sqrt2 * tvX[1], e, current_log_proj,
+                            n, c->work_logdet, stats, warmstart);
+  SPECTRAL_TIMING(c->tot_time_vec_cone_proj += SCS(tocq)(&_timer);)
+
+  if (status < 0) {
+    return status;
+  }
+  // return immediately if the origin is the solution
+  else if (status == IN_NEGATIVE_DUAL_CONE) {
+    memset(tvX, 0, sizeof(scs_float) * ((n * (n + 1)) / 2 + 2));
+    return 0;
+  }
+
+  // ----------------------------------------------------------------------
+  //             recover projection onto spectral *matrix* cone
+  // ----------------------------------------------------------------------
+  scs_float *evals_proj = current_log_proj + 2;
+  for (i = 0; i < n; ++i) {
+    assert(evals_proj[i] >= 0);
+    sq_eig_pos = SQRTF(evals_proj[i]);
+    BLAS(scal)(&nb, &sq_eig_pos, &Xs[i * n], &one_int);
+  }
+
+  BLAS(syrk)("Lower", "NoTrans", &nb, &nb, &one, Xs, &nb, &zero, Z, &nb);
+  BLAS(scal)(&nb, &sqrt2_inv, Z, &nb_plus_one);
+
+  for (i = 0; i < n; ++i) {
+    memcpy(&(X[i * n - ((i - 1) * i) / 2]), &(Z[i * (n + 1)]),
+           (n - i) * sizeof(scs_float));
+  }
+  tvX[0] = sqrt2_inv * current_log_proj[0];
+  tvX[1] = sqrt2_inv * current_log_proj[1];
+
+  return 0;
+}