scs 0.5.6 → 0.6.0

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

@@ -1,8 +1,8 @@
-#include "glbopts.h" // for scs_printf
+#include "glbopts.h" /* for scs_printf */
 #include "linalg.h"
 #include "scs_blas.h"
 #include "util_spectral_cones.h"
-#include <string.h> // for memcpy
+#include <string.h> /* for memcpy */
 
 /*
  * Spectral matrix cone projections, from "Projection onto Spectral Matrix
@@ -33,18 +33,23 @@
 #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
+/*
+ * 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;
+  scs_float sx;
+  scs_float obj;
+  scs_int i;
 
   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) {
+  sx = -(v * sum_log(x, n) - n * v * log(v));
+  obj = 0.5 * (sx - t0) * (sx - t0) + 0.5 * (v - v0) * (v - v0);
+  for (i = 0; i < n; ++i) {
     obj += 0.5 * (x[i] - x0[i]) * (x[i] - x0[i]);
   }
   return obj;
@@ -58,17 +63,27 @@ scs_int log_cone_Newton(scs_float t0, scs_float v0, const scs_float *x0,
   scs_float *x = u + 2;
   scs_int n_plus_one = n + 1;
 
-  // -------------------------------------------------------------------------
-  //     check cone membership and special cases with analytic projections
-  // -------------------------------------------------------------------------
+  /* check cone membership and special cases with analytic projections */
   bool ix_x0_non_neg = true;
   bool is_x0_pos = true;
   scs_int i = 0;
+
+  scs_float obj_old;
+  scs_float *grad;
+  scs_float *d;
+  scs_float *w;
+  scs_float *du;
+  scs_float *temp1;
+  scs_float *u_new;
+  size_t num_grad_steps;
+  scs_int iter;
+  scs_float newton_decrement;
+
   while (ix_x0_non_neg || is_x0_pos) {
-    if (x[i] < 0) {
+    if (x0[i] < 0) {
       ix_x0_non_neg = false;
       is_x0_pos = false;
-    } else if (x[i] == 0) {
+    } else if (x0[i] == 0) {
       is_x0_pos = false;
     }
 
@@ -78,7 +93,7 @@ scs_int log_cone_Newton(scs_float t0, scs_float v0, const scs_float *x0,
     ++i;
   }
 
-  // if (t0, v0, x0) belongs to cone
+  /* 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;
@@ -89,7 +104,7 @@ scs_int log_cone_Newton(scs_float t0, scs_float v0, const scs_float *x0,
     return 0;
   }
 
-  // if (t0, v0, x0) belongs to negative dual cone
+  /* 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) {
@@ -100,14 +115,16 @@ scs_int log_cone_Newton(scs_float t0, scs_float v0, const scs_float *x0,
     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
+      /*
+       * 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
+  /* special case with analytic solution */
   if (v0 <= 0 && t0 >= 0) {
     *t = t0;
     *v = 0;
@@ -117,84 +134,94 @@ scs_int log_cone_Newton(scs_float t0, scs_float v0, const scs_float *x0,
     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' 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) {
+    for (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;
+  obj_old = obj_val(u + 1, t0, v0, x0, n);
+
+  /* parse workspace */
+  grad = workspace;
+  d = grad + n_plus_one;
+  w = d + n_plus_one;
+  du = w + n_plus_one;
+  temp1 = du + n_plus_one;
+  u_new = du + n_plus_one + 1;
+
+  num_grad_steps = 0;
+  iter = 0;
+  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.
+    scs_float temp0;
+    scs_float a;
+    scs_float c;
+    scs_float v_inv;
+    scs_float av;
+    scs_float nominator;
+    scs_float denominator;
+    scs_float ratio;
+    scs_float dirDer;
+    scs_float step_size;
+    scs_float new_obj;
+
+    /*
+     * 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++) {
+    /*
+     * To avoid pathological cases where some components of
+     * x approach 0 we use a minimum threshold.
+     */
+    for (i = 0; i < n; i++) {
       x[i] = MAX(x[i], MIN_X);
     }
 
-    // ----------------------------------------------------------------
-    //                  compute gradient and Hessian
-    // ----------------------------------------------------------------
+    /* 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;
+    temp0 = -sum_log(x, n) + n * log(*v);
+    a = (*v) * temp0 - t0;
+    c = temp0 + n;
 
     grad[0] = a * c + (*v) - v0;
-    scs_float v_inv = 1 / (*v);
+    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);
+    av = a * (*v);
 
     for (i = 1; i < n + 1; ++i) {
-      assert(x[i - 1] > 0);
       scs_float x_inv = 1 / x[i - 1];
+      assert(x[i - 1] > 0);
       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;
+    /*
+     * 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.
+     */
+    nominator = 0;
+    denominator = 1;
     for (i = 0; i < n + 1; ++i) {
       assert(fabs(d[i]) > MIN_FLOAT);
       du[i] = -grad[i] / d[i];
@@ -208,15 +235,15 @@ scs_int log_cone_Newton(scs_float t0, scs_float v0, const scs_float *x0,
       return -1;
     }
 
-    scs_float ratio = -nominator / denominator;
+    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 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.
+     */
+    dirDer = SCS(dot)(grad, du, n_plus_one);
     if (dirDer > 0) {
       if (num_grad_steps >= MAX_GRAD_STEPS) {
         stats->iter = MAX_GRAD_STEPS_REACHED;
@@ -232,18 +259,14 @@ scs_int log_cone_Newton(scs_float t0, scs_float v0, const scs_float *x0,
       }
     }
 
-    // --------------------------------------------------------
-    // compute Newton decrement and check termination criteria
-    // -------------------------------------------------------
+    /* 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;
+    /* find largest step size with respect to the domain */
+    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];
@@ -251,13 +274,13 @@ scs_int log_cone_Newton(scs_float t0, scs_float v0, const scs_float *x0,
       }
     }
 
-    // -------------------------------------------------
-    // backtracking line search. First two lines do
-    // u_new = u + t * du;
-    // -------------------------------------------------
+    /*
+     * 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);
+    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;

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

@@ -28,17 +28,17 @@
  * Last modified: 25 August 2024.
  */
 
-// forward declare from log_cone_Newton.c
+/* 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
+/* 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
+/* 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],
@@ -48,17 +48,17 @@ 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.
-  // ------------------------------------------------------------------------
+  /*
+   * 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)) {
@@ -74,14 +74,14 @@ scs_int log_cone_proj_wrapper(scs_float t0, scs_float v0, scs_float *x0,
     return 0;
   }
 
-  // ------------------------------------------------------------------------
-  // Solve problem with primal-dual IPM incorporating Mehrotra's correction
-  // etc.
-  // ------------------------------------------------------------------------
+  /*
+   * 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
+  *warm_start = true; /* next iteration Newton should be warmstarted */
 
   if (status == 0 && stats->residuals[0] < DUAL_FEAS_TOL &&
       stats->residuals[1] < PRI_FEAS_TOL &&
@@ -90,15 +90,15 @@ scs_int log_cone_proj_wrapper(scs_float t0, scs_float v0, scs_float *x0,
     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.)
-  // ------------------------------------------------------------------------
+  /*
+   * 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);
 
@@ -110,71 +110,73 @@ scs_int log_cone_proj_wrapper(scs_float t0, scs_float v0, scs_float *x0,
   }
 
 #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_int i;
+    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 (i = 0; i < n; i++) {
+      scs_printf(" %.10e", x0[i]);
+    }
+    scs_printf("\n");
   }
-  scs_printf("\n");
 #endif
 
   return -1;
 }
 
-// tvx = [t, v, x].
+/* 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;
+  scs_float dualt;
+  scs_float dualv;
+  scs_int i;
+  scs_float dual_norm;
+  scs_float pri_norm;
+  double scale;
+
+  /* Compute Lagrange multiplier */
+  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) {
+  dualv = tvx[1] - v0;
+  for (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
-  // ---------------------------------------------------------------------
+  /* Compute complementarity measure */
   complementarity =
       tvx[0] * dualt + tvx[1] * dualv + SCS(dot)(dualx, tvx + 2, n);
 
-  // ----------------------------------------------------------------------
-  //          Compute primal feasibility measure
-  // ----------------------------------------------------------------------
+  /* 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 {
+    const scs_float *xi;
     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) {
+    for (xi = tvx + 2; xi < tvx + 2 + n; ++xi) {
       if (*xi < 0) {
         pri_res += (*xi) * (*xi);
       }
     }
   }
 
-  // ----------------------------------------------------------------------
-  //          Compute dual feasibility measure
-  // ----------------------------------------------------------------------
+  /* Compute dual feasibility measure */
   if (dualt > 0 && is_pos(dualx, n)) {
     dual_res = dualt * (n * log(dualt) - n - sum_log(dualx, n)) - dualv;
   } else {
@@ -184,22 +186,19 @@ static void check_opt_cond_log_cone(const scs_float *tvx, scs_float t0,
       dual_res += dualv * dualv;
     }
 
-    for (scs_int i = 0; i < n; i++) {
+    for (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 =
+  /* Normalize the residuals and assign the result */
+  dual_norm =
       sqrt(dualt * dualt + dualv * dualv + SCS(norm_sq)(dualx, n));
-  scs_float pri_norm = SCS(norm_2)(tvx, n + 2);
+  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);
+  scale = MAX(pri_norm, 1.0);
   residuals[2] = complementarity / MAX(scale, dual_norm);
 }
-