scs 0.5.6 → 0.6.0

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

@@ -6,6 +6,8 @@
 #include "util.h"
 #include "util_spectral_cones.h"
 
+#include <string.h>
+
 /*
  * Spectral matrix cone projections, from "Projection onto Spectral Matrix
  * Cones" by Daniel Cederberg and Stephen Boyd, 2024.
@@ -36,7 +38,7 @@ void BLAS(scal)(const blas_int *n, const scs_float *sa, scs_float *sx,
 }
 #endif
 
-// forward declare from log_cone_wrapper.c
+/* 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);
@@ -45,9 +47,11 @@ 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)
+  /*
+   * 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
@@ -57,87 +61,90 @@ scs_int SCS(proj_logdet_cone)(scs_float *tvX, scs_int n, ScsConeWork *c,
   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));
-  }
+  /* 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;
+    scs_float *current_log_proj;
+    scs_int status;
+    scs_float *evals_proj;
+
+    /* 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;
+    /* 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;
-  }
+    /*
+     * 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)
+     */
+    current_log_proj = c->saved_log_projs + offset;
+    SPECTRAL_TIMING(SCS(timer) _timer; SCS(tic)(&_timer);)
+    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);
-  }
+    /* recover projection onto spectral *matrix* cone */
+    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);
+    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));
+    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];
   }
-  tvX[0] = sqrt2_inv * current_log_proj[0];
-  tvX[1] = sqrt2_inv * current_log_proj[1];
 
   return 0;
 }

data/vendor/scs/src/spectral_cones/nuclear/ell1_cone.c

@@ -1,11 +1,12 @@
 #include "cones.h"
-// #include "scs.h"
 #include "linalg.h"
 #include "scs_blas.h"
 #include "scs_types.h"
-#include "util.h" // just for timer
+#include "util.h"
 #include "util_spectral_cones.h"
-#include <stdlib.h> // qsort
+
+#include <stdlib.h>
+#include <string.h>
 
 /*
  * Spectral matrix cone projections, from "Projection onto Spectral Matrix
@@ -38,50 +39,53 @@ static void compute_cone_residuals_ell1(const scs_float *tx, scs_float t0,
                                         const scs_float *x0, scs_int n,
                                         scs_float residuals[3]) {
   scs_float dual_res, pri_res, complementarity;
-
-  // -------------------------------------
-  //      Compute Lagrange multiplier.
-  // (This function is not used in production so it is fine to allocate
-  // memory here)
-  // -------------------------------------
   scs_float dualt = tx[0] - t0;
   scs_float *dualx = malloc(n * sizeof(scs_float));
-  memcpy(dualx, tx + 1, n * sizeof(scs_float));
   blas_int int_n = n;
   scs_float negOne = -1.0;
   blas_int one = 1;
+  scs_float ell1_norm = 0;
+  scs_float inf_norm = 0;
+  scs_float abs_val;
+  const scs_float *xi;
+  scs_int i;
+
+  /* -------------------------------------
+   *      Compute Lagrange multiplier.
+   * (This function is not used in production so it is fine to allocate
+   * memory here)
+   * ------------------------------------- */
+  memcpy(dualx, tx + 1, n * sizeof(scs_float));
   BLAS(axpy)(&int_n, &negOne, x0, &one, dualx, &one);
 
-  // ---------------------------------------
-  //     Compute complementarity measure
-  // ---------------------------------------
+  /* ---------------------------------------
+   *     Compute complementarity measure
+   * --------------------------------------- */
   complementarity =
       tx[0] * dualt + BLAS(dot)(&int_n, dualx, &one, tx + 1, &one);
 
-  // -----------------------------------------------
-  //   Compute primal feasibility measure
-  // -----------------------------------------------
-  scs_float ell1_norm = 0;
-  for (const scs_float *xi = tx + 1; xi < tx + 1 + n; ++xi) {
+  /* -----------------------------------------------
+   *   Compute primal feasibility measure
+   * ----------------------------------------------- */
+  for (xi = tx + 1; xi < tx + 1 + n; ++xi) {
     ell1_norm += fabs(*xi);
   }
   pri_res = ell1_norm - tx[0];
 
-  // ---------------------------------------
-  //   Compute dual feasibility measure
-  // ---------------------------------------
-  scs_float inf_norm = 0;
-  for (scs_int i = 0; i < n; ++i) {
-    scs_float abs_val = fabs(dualx[i]);
+  /* ---------------------------------------
+   *   Compute dual feasibility measure
+   * --------------------------------------- */
+  for (i = 0; i < n; ++i) {
+    abs_val = fabs(dualx[i]);
     if (abs_val > inf_norm) {
       inf_norm = abs_val;
     }
   }
   dual_res = inf_norm - dualt;
 
-  // ------------------------------------------
-  //  Assign result and free allocated memory
-  // ------------------------------------------
+  /* ------------------------------------------
+   *  Assign result and free allocated memory
+   * ------------------------------------------ */
   residuals[0] = dual_res;
   residuals[1] = pri_res;
   residuals[2] = complementarity;
@@ -89,90 +93,82 @@ static void compute_cone_residuals_ell1(const scs_float *tx, scs_float t0,
 }
 #endif
 
-// Asssumes that all components of x0 are positive and
-// x0[0] >= x0[1] >= ... x0[n-1].
+/* Assumes that all components of x0 are nonnegative and
+ * x0[0] >= x0[1] >= ... x0[n-1].
+ *
+ * Projects (t0, x0) onto {(t, x) : ||x||_1 <= t}. For sorted nonnegative
+ * input the projection is proj_x[i] = max(x0[i] - theta, 0) and
+ * proj_t = t0 + theta, where theta = (sum_{i<k} x0[i] - t0) / (k + 1) and
+ * k is the largest index with x0[k-1] - theta(k) > 0 (Duchi et al. 2008,
+ * "Efficient projections onto the l1-ball"). Scanning for the largest such
+ * k is robust to repeated entries, where two-sided bracket searches can
+ * fail to fire and produce points far outside the cone. */
 scs_int ell1_cone_proj_sorted(scs_float t0, const scs_float *x0,
                               scs_float *proj, scs_int n) {
+  scs_float xSum, theta, th;
+  scs_int k, kk, i;
+
   if (-t0 >= x0[0]) {
+    /* (t0, x0) lies in the polar cone: projection is the origin */
     memset(proj, 0, (n + 1) * sizeof(*x0));
     return 0;
   }
 
-  // -------------------------------------------
-  //            Find the value on k
-  // -------------------------------------------
-
-  // check if k = 0 suffices
-  if (-t0 >= x0[0]) {
-    memset(proj, 0, (n + 1) * sizeof(*x0));
+  xSum = 0;
+  for (i = 0; i < n; ++i) {
+    xSum += x0[i];
+  }
+  if (xSum <= t0) {
+    /* (t0, x0) already lies in the cone: projection is the identity */
+    proj[0] = t0;
+    memcpy(proj + 1, x0, n * sizeof(*x0));
     return 0;
   }
 
-  scs_float xSum = 0;
-  scs_float tempSum = 0;
-  int k = -1;
-  for (scs_int kk = 1; kk < n; ++kk) {
+  xSum = 0;
+  theta = 0;
+  k = 0;
+  for (kk = 1; kk <= n; ++kk) {
     xSum += x0[kk - 1];
-    tempSum = (-t0 + xSum) / (kk + 1);
-
-    if (x0[kk - 1] > tempSum && x0[kk] <= tempSum) {
-      k = (int)kk;
+    th = (xSum - t0) / (kk + 1);
+    if (x0[kk - 1] - th > 0) {
+      k = kk;
+      theta = th;
+    } else {
+      /* x0 is nonincreasing and theta(kk) nondecreasing: no later kk works */
       break;
     }
   }
 
-  if (k == -1) {
-    k = n;
-    xSum += x0[n - 1];
-  }
-
-  // ---------------------------------------------
-  //                Execute projection
-  // ---------------------------------------------
-  proj[0] = -t0 + xSum;
-
-  if (proj[0] > 0) {
-    proj[0] = t0 + proj[0] / (k + 1);
-  } else {
-    proj[0] = t0;
+  if (k == 0) {
+    /* only reachable through rounding on polar-boundary inputs */
+    memset(proj, 0, (n + 1) * sizeof(*x0));
+    return 0;
   }
 
-  memcpy(proj + 1, x0, k * sizeof(*x0));
-  scs_float diff = proj[0] - t0;
-  for (int i = 1; i < k + 1; i++) {
-    proj[i] -= diff;
+  proj[0] = MAX(t0 + theta, 0.);
+  for (i = 0; i < k; ++i) {
+    proj[i + 1] = x0[i] - theta;
   }
   memset(proj + 1 + k, 0, (n - k) * sizeof(*x0));
-
-#ifdef SPECTRAL_DEBUG
-  //-------------------------------------------------------------------------
-  //               Check residuals - not needed in production
-  //-------------------------------------------------------------------------
-  scs_float residuals[3];
-  compute_cone_residuals_ell1(proj, t0, x0, n, residuals);
-
-  if (residuals[0] > 1e-8 || residuals[1] > 1e-8 || residuals[2] > 1e-8) {
-    scs_printf("WARN: something is wrong in nuclear norm cone projection.\n");
-    scs_printf("dual_res / primal_res / comp : %.3e, %.3e, %.3e\n",
-               residuals[0], residuals[1], residuals[2]);
-    return -1;
-  }
-#endif
-
   return 0;
 }
 
 static void in_place_shuffle_ell1(scs_float *x, Value_index *work, scs_int n) {
-  for (scs_int i = 0; i < n; ++i) {
+  scs_int i;
+  scs_int target_idx;
+  scs_int temp_idx;
+  scs_float temp_x;
+  for (i = 0; i < n; ++i) {
     while (work[i].index != i) {
-      // Swap elements in `x`
-      scs_int target_idx = work[i].index;
-      scs_float temp_x = x[i];
+      /* Swap elements in `x` */
+      target_idx = work[i].index;
+      temp_x = x[i];
       x[i] = x[target_idx];
       x[target_idx] = temp_x;
 
-      // Swap indices in `idxs` to reflect the change
-      scs_int temp_idx = work[i].index;
+      /* Swap indices in `idxs` to reflect the change */
+      temp_idx = work[i].index;
       work[i].index = work[target_idx].index;
       work[target_idx].index = temp_idx;
     }
@@ -182,7 +178,10 @@ static void in_place_shuffle_ell1(scs_float *x, Value_index *work, scs_int n) {
 int custom_cmp(const void *a, const void *b) {
   Value_index *elemA = (Value_index *)a;
   Value_index *elemB = (Value_index *)b;
-  return fabs(elemB->value) - fabs(elemA->value) > 0 ? 1 : -1;
+  scs_float diff = fabs(elemB->value) - fabs(elemA->value);
+  if (diff > 0) return 1;
+  if (diff < 0) return -1;
+  return 0;
 }
 
 void SCS(proj_ell_one)(scs_float *tx, scs_int n, ScsConeWork *c) {
@@ -190,30 +189,26 @@ void SCS(proj_ell_one)(scs_float *tx, scs_int n, ScsConeWork *c) {
   scs_float *x0 = tx + 1;
   scs_float *proj = c->work_ell1_proj;
   Value_index *work = c->work_ell1;
-  // ------------------------------------------------------
-  //     Preprocess vector so it is nonnegative and sorted
-  // ------------------------------------------------------
-  for (scs_int i = 0; i < n; ++i) {
+  scs_int i;
+
+  /* Preprocess vector so it is nonnegative and sorted */
+  for (i = 0; i < n; ++i) {
     work[i].value = fabs(x0[i]);
     work[i].index = i;
   }
 
   qsort(work, n, sizeof(Value_index), custom_cmp);
 
-  for (scs_int i = 0; i < n; ++i) {
+  for (i = 0; i < n; ++i) {
     proj[i + 1] = work[i].value;
   }
 
-  // ------------------------------------------
-  //        project preprocessed vector
-  // ------------------------------------------
+  /* project preprocessed vector */
   ell1_cone_proj_sorted(t0, proj + 1, proj, n);
 
-  // -------------------------------------------
-  //        recover original vector
-  // -------------------------------------------
+  /* recover original vector */
   in_place_shuffle_ell1(proj + 1, work, n);
-  for (scs_int i = 0; i < n; i++) {
+  for (i = 0; i < n; i++) {
     proj[i + 1] = proj[i + 1] * (x0[i] >= 0 ? 1 : -1);
   }
 

data/vendor/scs/src/spectral_cones/nuclear/nuclear_cone.c

@@ -1,9 +1,9 @@
 #include "cones.h"
-// #include "scs.h"
+/* #include "scs.h" */
 #include "linalg.h"
 #include "scs_blas.h"
 #include "scs_types.h"
-#include "util.h" // just for timer
+#include "util.h" /* just for timer */
 
 /*
  * Spectral matrix cone projections, from "Projection onto Spectral Matrix
@@ -39,28 +39,42 @@ void BLAS(gesvd)(const char *jobu, const char *jobvt, const blas_int *m,
 }
 #endif
 
-// forward declaration from ell1_cone.c
+/* forward declaration from ell1_cone.c */
 scs_int ell1_cone_proj_sorted(scs_float t0, const scs_float *x0,
                               scs_float *proj, scs_int n);
 
-// X is of size m x n, stored column major. It is assumed that m >= n.
+/* X is of size m x n, stored column major. It is assumed that m >= n. */
 scs_int SCS(proj_nuclear_cone)(scs_float *tX, scs_int m, scs_int n,
                                ScsConeWork *c) {
+  scs_float *X;
+  blas_int bm;
+  blas_int bn;
+  scs_float *s;
+  scs_float *u;
+  scs_float *vt;
+  scs_float *work;
+  blas_int lwork;
+  blas_int info;
+  scs_int status;
+  blas_int one;
+  scs_int i;
+  char trans;
+  scs_float alpha;
+  scs_float beta;
+
   assert(m >= n);
-  scs_float *X = tX + 1;
-  blas_int bm = m;
-  blas_int bn = n;
+  X = tX + 1;
+  bm = m;
+  bn = n;
 
-  // -------------------------------------------------------------------------
-  //                            Compute SVD
-  // -------------------------------------------------------------------------
-  scs_float *s = c->s_nuc;
-  scs_float *u = c->u_nuc;
-  scs_float *vt = c->vt_nuc;
+  /* Compute SVD */
+  s = c->s_nuc;
+  u = c->u_nuc;
+  vt = c->vt_nuc;
 
-  scs_float *work = c->work_nuc;
-  int lwork = c->lwork_nuc;
-  int info = 0;
+  work = c->work_nuc;
+  lwork = c->lwork_nuc;
+  info = 0;
 
   BLAS(gesvd)("S", "A", &bm, &bn, X, &bm, s, u, &bm, vt, &bn, work, &lwork,
               &info);
@@ -70,28 +84,25 @@ scs_int SCS(proj_nuclear_cone)(scs_float *tX, scs_int m, scs_int n,
       return info;
     }
   }
-  // -------------------------------------------------------------------------
-  //                  Project onto spectral *vector* cone
-  // -------------------------------------------------------------------------
+
+  /* Project onto spectral *vector* cone */
   SPECTRAL_TIMING(SCS(timer) _timer; SCS(tic)(&_timer);)
-  scs_int status = ell1_cone_proj_sorted(tX[0], s, tX, n);
+  status = ell1_cone_proj_sorted(tX[0], s, tX, n);
   SPECTRAL_TIMING(c->tot_time_vec_cone_proj += SCS(tocq)(&_timer);)
 
   if (status < 0) {
     return status;
   }
 
-  // -------------------------------------------------------------------------
-  //  Recover projection onto spectral *matrix* cone
-  // -------------------------------------------------------------------------
-  int one = 1;
-  for (scs_int i = 0; i < n; ++i) {
+  /* Recover projection onto spectral *matrix* cone */
+  one = 1;
+  for (i = 0; i < n; ++i) {
     BLAS(scal)(&bm, &tX[i + 1], &u[i * m], &one);
   }
 
-  char trans = 'N';
-  scs_float alpha = 1.0;
-  scs_float beta = 0.0;
+  trans = 'N';
+  alpha = 1.0;
+  beta = 0.0;
   BLAS(gemm)(&trans, &trans, &bm, &bn, &bn, &alpha, u, &bm, vt, &bn, &beta,
              tX + 1, &bm);