scs 0.5.6 → 0.6.0

data/vendor/scs/src/ctrlc.c

@@ -33,49 +33,92 @@ int scs_is_interrupted(void) {
 #elif (defined _WIN32 || _WIN64 || defined _WINDLL)
 #include <windows.h>
 
-static int int_detected;
+static volatile LONG int_detected;
+static INIT_ONCE ctrlc_init_once = INIT_ONCE_STATIC_INIT;
+static CRITICAL_SECTION ctrlc_cs;
+static int listener_count = 0;
+
+static BOOL CALLBACK init_ctrlc_cs(PINIT_ONCE once, PVOID param, PVOID *ctx) {
+  (void)once;
+  (void)param;
+  (void)ctx;
+  InitializeCriticalSection(&ctrlc_cs);
+  return TRUE;
+}
+
 static BOOL WINAPI scs_handle_ctrlc(DWORD dwCtrlType) {
   if (dwCtrlType != CTRL_C_EVENT) {
     return FALSE;
   }
-  int_detected = 1;
+  InterlockedExchange(&int_detected, 1);
   return TRUE;
 }
 
 void scs_start_interrupt_listener(void) {
-  int_detected = 0;
-  SetConsoleCtrlHandler(scs_handle_ctrlc, TRUE);
+  InitOnceExecuteOnce(&ctrlc_init_once, init_ctrlc_cs, NULL, NULL);
+  EnterCriticalSection(&ctrlc_cs);
+  if (listener_count == 0) {
+    InterlockedExchange(&int_detected, 0);
+    SetConsoleCtrlHandler(scs_handle_ctrlc, TRUE);
+  }
+  listener_count++;
+  LeaveCriticalSection(&ctrlc_cs);
 }
 
 void scs_end_interrupt_listener(void) {
-  SetConsoleCtrlHandler(scs_handle_ctrlc, FALSE);
+  InitOnceExecuteOnce(&ctrlc_init_once, init_ctrlc_cs, NULL, NULL);
+  EnterCriticalSection(&ctrlc_cs);
+  if (listener_count > 0) {
+    listener_count--;
+    if (listener_count == 0) {
+      SetConsoleCtrlHandler(scs_handle_ctrlc, FALSE);
+    }
+  }
+  LeaveCriticalSection(&ctrlc_cs);
 }
 
 int scs_is_interrupted(void) {
-  return int_detected;
+  return (int)InterlockedCompareExchange(&int_detected, 0, 0);
 }
 
 #else /* Unix */
 
 #include <signal.h>
-static int int_detected;
-struct sigaction oact;
+#include <pthread.h>
+
+static volatile sig_atomic_t int_detected;
+static struct sigaction oact;
+static pthread_mutex_t ctrlc_mutex = PTHREAD_MUTEX_INITIALIZER;
+static int listener_count = 0;
+
 static void scs_handle_ctrlc(int dummy) {
   int_detected = dummy ? dummy : -1;
 }
 
 void scs_start_interrupt_listener(void) {
-  struct sigaction act;
-  int_detected = 0;
-  act.sa_flags = 0;
-  sigemptyset(&act.sa_mask);
-  act.sa_handler = scs_handle_ctrlc;
-  sigaction(SIGINT, &act, &oact);
+  pthread_mutex_lock(&ctrlc_mutex);
+  if (listener_count == 0) {
+    struct sigaction act;
+    int_detected = 0;
+    act.sa_flags = 0;
+    sigemptyset(&act.sa_mask);
+    act.sa_handler = scs_handle_ctrlc;
+    sigaction(SIGINT, &act, &oact);
+  }
+  listener_count++;
+  pthread_mutex_unlock(&ctrlc_mutex);
 }
 
 void scs_end_interrupt_listener(void) {
-  struct sigaction act;
-  sigaction(SIGINT, &oact, &act);
+  pthread_mutex_lock(&ctrlc_mutex);
+  if (listener_count > 0) {
+    listener_count--;
+    if (listener_count == 0) {
+      struct sigaction act;
+      sigaction(SIGINT, &oact, &act);
+    }
+  }
+  pthread_mutex_unlock(&ctrlc_mutex);
 }
 
 int scs_is_interrupted(void) {

data/vendor/scs/src/exp_cone.c

@@ -1,3 +1,8 @@
+/*
+ * Exponential cone projection via Newton's method.
+ * Handles both primal and dual exponential cones using Moreau decomposition.
+ */
+
 #include "cones.h"
 #include "glbopts.h"
 #include "linalg.h"
@@ -25,14 +30,29 @@ static inline void _copy(scs_float *dest, const scs_float *src) {
   dest[2] = src[2];
 }
 
-/* As defined in Friberg, 2021 (multiplied by positive polynomial) */
-static void hfun(const scs_float *v0, scs_float rho, scs_float *f,
-                 scs_float *df) {
+static inline scs_float norm_diff_sq_3(const scs_float *a, const scs_float *b) {
+  scs_float d0 = a[0] - b[0];
+  scs_float d1 = a[1] - b[1];
+  scs_float d2 = a[2] - b[2];
+  return d0 * d0 + d1 * d1 + d2 * d2;
+}
+
+/* As defined in Friberg, 2021 (multiplied by positive polynomial). */
+static scs_float hfun_f(const scs_float *v0, scs_float rho) {
+  scs_float t0 = v0[2], s0 = v0[1], r0 = v0[0];
+  scs_float exprho = EXPF(rho);
+  scs_float expnegrho = 1.0 / exprho; /* EXPF(-rho) == 1/EXPF(rho) */
+
+  return ((rho - 1) * r0 + s0) * exprho - (r0 - rho * s0) * expnegrho -
+         (rho * (rho - 1) + 1) * t0;
+}
+
+static void hfun_fd(const scs_float *v0, scs_float rho, scs_float *f,
+                    scs_float *df) {
   scs_float t0 = v0[2], s0 = v0[1], r0 = v0[0];
   scs_float exprho = EXPF(rho);
-  scs_float expnegrho = EXPF(-rho);
+  scs_float expnegrho = 1.0 / exprho; /* EXPF(-rho) == 1/EXPF(rho) */
 
-  /* Function value at v0 */
   *f = ((rho - 1) * r0 + s0) * exprho - (r0 - rho * s0) * expnegrho -
        (rho * (rho - 1) + 1) * t0;
 
@@ -47,14 +67,14 @@ static scs_float root_search_binary(const scs_float *v0, scs_float xl,
   const scs_float EPS = 1e-12; /* looser tolerance for binary search */
   const scs_int MAXITER = 40;
   scs_int i;
-  scs_float x_plus = x, f, df;
+  scs_float x_plus = x, f;
 
 #if VERBOSITY > 0
   scs_printf("Exp cone: Newton method failed, resorting to binary search.\n");
 #endif
 
   for (i = 0; i < MAXITER; i++) {
-    hfun(v0, x, &f, &df);
+    f = hfun_f(v0, x);
 
     if (f < 0.0) {
       xl = x;
@@ -88,7 +108,7 @@ static scs_float root_search_newton(const scs_float *v0, scs_float xl,
   scs_int i;
 
   for (i = 0; i < MAXITER; i++) {
-    hfun(v0, x, &f, &df);
+    hfun_fd(v0, x, &f, &df);
 
     if (ABS(f) <= EPS) { /* root found */
       break;
@@ -145,52 +165,52 @@ static scs_float root_search_newton(const scs_float *v0, scs_float xl,
 static scs_float proj_primal_exp_cone_heuristic(const scs_float *v0,
                                                 scs_float *vp) {
   scs_float t0 = v0[2], s0 = v0[1], r0 = v0[0];
-  scs_float dist, tp, newdist;
+  scs_float dist_sq, tp, newdist_sq;
 
   /* Perspective boundary */
   vp[2] = MAX(t0, 0.0);
   vp[1] = 0.0;
   vp[0] = MIN(r0, 0.0);
-  dist = SCS(norm_diff)(v0, vp, 3);
+  dist_sq = norm_diff_sq_3(v0, vp);
 
   /* Perspective interior */
   if (s0 > 0.0) {
     tp = MAX(t0, s0 * EXPF(r0 / s0));
-    newdist = tp - t0;
-    if (newdist < dist) {
+    newdist_sq = (tp - t0) * (tp - t0);
+    if (newdist_sq < dist_sq) {
       vp[2] = tp;
       vp[1] = s0;
       vp[0] = r0;
-      dist = newdist;
+      dist_sq = newdist_sq;
     }
   }
-  return dist;
+  return dist_sq;
 }
 
 /* Try heuristic (cheap) projection for polar cone */
 static scs_float proj_polar_exp_cone_heuristic(const scs_float *v0,
                                                scs_float *vd) {
   scs_float t0 = v0[2], s0 = v0[1], r0 = v0[0];
-  scs_float dist, td, newdist;
+  scs_float dist_sq, td, newdist_sq;
 
   /* Perspective boundary */
   vd[2] = MIN(t0, 0.0);
   vd[1] = MIN(s0, 0.0);
   vd[0] = 0.0;
-  dist = SCS(norm_diff)(v0, vd, 3);
+  dist_sq = norm_diff_sq_3(v0, vd);
 
   /* Perspective interior */
   if (r0 > 0.0) {
     td = MIN(t0, -r0 * EXPF(s0 / r0 - 1.0));
-    newdist = t0 - td;
-    if (newdist < dist) {
+    newdist_sq = (t0 - td) * (t0 - td);
+    if (newdist_sq < dist_sq) {
       vd[2] = td;
       vd[1] = s0;
       vd[0] = r0;
-      dist = newdist;
+      dist_sq = newdist_sq;
     }
   }
-  return dist;
+  return dist_sq;
 }
 
 static scs_float ppsi(const scs_float *v0) {
@@ -238,18 +258,18 @@ static scs_float domega(scs_float rho) {
 }
 
 /* Generate upper and lower search bounds for root of hfun */
-static void exp_search_bracket(const scs_float *v0, scs_float pdist,
-                               scs_float ddist, scs_float *low_out,
+static void exp_search_bracket(const scs_float *v0, scs_float pdist_sq,
+                               scs_float ddist_sq, scs_float *low_out,
                                scs_float *upr_out) {
   scs_float t0 = v0[2], s0 = v0[1], r0 = v0[0];
   scs_float baselow = -EXP_CONE_INFINITY_VALUE;
   scs_float baseupr = EXP_CONE_INFINITY_VALUE;
   scs_float low = -EXP_CONE_INFINITY_VALUE;
   scs_float upr = EXP_CONE_INFINITY_VALUE;
-  scs_float Dp, Dd, curbnd, fl, fu, df, tpu, tdl, sgn, val;
+  scs_float Dp, Dd, curbnd, fl, fu, tpu, tdl, sgn, val;
 
-  Dp = SQRTF(pdist * pdist - MIN(s0, 0.0) * MIN(s0, 0.0));
-  Dd = SQRTF(ddist * ddist - MIN(r0, 0.0) * MIN(r0, 0.0));
+  Dp = SQRTF(MAX(pdist_sq - MIN(s0, 0.0) * MIN(s0, 0.0), 0.0));
+  Dd = SQRTF(MAX(ddist_sq - MIN(r0, 0.0) * MIN(r0, 0.0), 0.0));
 
   if (t0 > 0.0) {
     curbnd = LOGF(t0 / ppsi(v0));
@@ -286,8 +306,8 @@ static void exp_search_bracket(const scs_float *v0, scs_float pdist,
   upr = _clip(MAX(low, upr), baselow, baseupr);
 
   if (low != upr) {
-    hfun(v0, low, &fl, &df);
-    hfun(v0, upr, &fu, &df);
+    fl = hfun_f(v0, low);
+    fu = hfun_f(v0, upr);
 
     if (fl * fu > 0.0) {
       if (ABS(fl) < ABS(fu)) {
@@ -307,21 +327,21 @@ static scs_float proj_sol_primal_exp_cone(const scs_float *v0, scs_float rho,
                                           scs_float *vp) {
   scs_float linrho = (rho - 1.0) * v0[0] + v0[1];
   scs_float exprho = EXPF(rho);
-  scs_float quadrho, dist;
+  scs_float quadrho, dist_sq;
 
   if (linrho > 0.0 && _isfinite(exprho)) {
     quadrho = rho * (rho - 1.0) + 1.0;
     vp[2] = exprho * linrho / quadrho;
     vp[1] = linrho / quadrho;
     vp[0] = rho * linrho / quadrho;
-    dist = SCS(norm_diff)(vp, v0, 3);
+    dist_sq = norm_diff_sq_3(vp, v0);
   } else {
     vp[2] = EXP_CONE_INFINITY_VALUE;
     vp[1] = 0.0;
     vp[0] = 0.0;
-    dist = EXP_CONE_INFINITY_VALUE;
+    dist_sq = EXP_CONE_INFINITY_VALUE;
   }
-  return dist;
+  return dist_sq;
 }
 
 /* convert from rho to polar projection */
@@ -329,21 +349,21 @@ static scs_float proj_sol_polar_exp_cone(const scs_float *v0, scs_float rho,
                                          scs_float *vd) {
   scs_float linrho = v0[0] - rho * v0[1];
   scs_float exprho = EXPF(-rho);
-  scs_float quadrho, dist;
+  scs_float quadrho, dist_sq;
 
   if (linrho > 0.0 && _isfinite(exprho)) {
     quadrho = rho * (rho - 1.0) + 1.0;
     vd[2] = -exprho * linrho / quadrho;
     vd[1] = (1.0 - rho) * linrho / quadrho;
     vd[0] = linrho / quadrho;
-    dist = SCS(norm_diff)(v0, vd, 3);
+    dist_sq = norm_diff_sq_3(v0, vd);
   } else {
     vd[2] = -EXP_CONE_INFINITY_VALUE;
     vd[1] = 0.0;
     vd[0] = 0.0;
-    dist = EXP_CONE_INFINITY_VALUE;
+    dist_sq = EXP_CONE_INFINITY_VALUE;
   }
-  return dist;
+  return dist_sq;
 }
 
 /* Project onto primal or dual exponential cone, performed in-place.
@@ -352,7 +372,7 @@ static scs_float proj_sol_polar_exp_cone(const scs_float *v0, scs_float rho,
  */
 scs_float SCS(proj_pd_exp_cone)(scs_float *v0, scs_int primal) {
   scs_float TOL = 1e-8; /* pow(1e-10, 2.0 / 3.0); */
-  scs_float xl, xh, pdist, ddist, err, rho, dist_hat;
+  scs_float xl, xh, pdist_sq, ddist_sq, err, rho, dist_hat_sq;
   scs_float vp[3], vd[3], v_hat[3];
   scs_int opt;
 
@@ -366,8 +386,8 @@ scs_float SCS(proj_pd_exp_cone)(scs_float *v0, scs_int primal) {
     v0[2] *= -1.0;
   }
 
-  pdist = proj_primal_exp_cone_heuristic(v0, vp);
-  ddist = proj_polar_exp_cone_heuristic(v0, vd);
+  pdist_sq = proj_primal_exp_cone_heuristic(v0, vp);
+  ddist_sq = proj_polar_exp_cone_heuristic(v0, vd);
 
   err = ABS(vp[0] + vd[0] - v0[0]);
   err = MAX(err, ABS(vp[1] + vd[1] - v0[1]));
@@ -377,45 +397,45 @@ scs_float SCS(proj_pd_exp_cone)(scs_float *v0, scs_int primal) {
    * or optimality conditions are satisfied
    */
   opt = (v0[1] <= 0.0 && v0[0] <= 0.0);
-  opt |= (MIN(pdist, ddist) <= TOL);
+  opt |= (MIN(pdist_sq, ddist_sq) <= TOL * TOL);
   opt |= (err <= TOL && SCS(dot)(vp, vd, 3) <= TOL);
 
   if (opt) {
     if (primal) {
       _copy(v0, vp);
-      return pdist;
+      return SQRTF(pdist_sq);
     }
     /* Polar cone -> dual cone. */
     v0[0] = -vd[0];
     v0[1] = -vd[1];
     v0[2] = -vd[2];
-    return ddist;
+    return SQRTF(ddist_sq);
   }
 
-  exp_search_bracket(v0, pdist, ddist, &xl, &xh);
+  exp_search_bracket(v0, pdist_sq, ddist_sq, &xl, &xh);
   rho = root_search_newton(v0, xl, xh, 0.5 * (xl + xh));
 
   if (primal) {
     /* Primal cone projection. */
-    dist_hat = proj_sol_primal_exp_cone(v0, rho, v_hat);
-    if (dist_hat <= pdist) {
+    dist_hat_sq = proj_sol_primal_exp_cone(v0, rho, v_hat);
+    if (dist_hat_sq <= pdist_sq) {
       _copy(vp, v_hat);
-      pdist = dist_hat;
+      pdist_sq = dist_hat_sq;
     }
     _copy(v0, vp);
-    return pdist;
+    return SQRTF(pdist_sq);
   }
 
   /* Polar cone projection. */
-  dist_hat = proj_sol_polar_exp_cone(v0, rho, v_hat);
-  if (dist_hat <= ddist) {
+  dist_hat_sq = proj_sol_polar_exp_cone(v0, rho, v_hat);
+  if (dist_hat_sq <= ddist_sq) {
     _copy(vd, v_hat);
-    ddist = dist_hat;
+    ddist_sq = dist_hat_sq;
   }
 
   /* Polar cone -> dual cone. */
   v0[0] = -vd[0];
   v0[1] = -vd[1];
   v0[2] = -vd[2];
-  return ddist;
+  return SQRTF(ddist_sq);
 }

data/vendor/scs/src/linalg.c

@@ -1,3 +1,9 @@
+/*
+ * Dense linear algebra operations: norms, dot products, scaling, axpy.
+ * Has two implementations: a plain C fallback and an optimized BLAS version
+ * (selected at compile time via USE_LAPACK).
+ */
+
 #include "linalg.h"
 #include "scs_blas.h"
 #include <math.h>
@@ -136,8 +142,9 @@ scs_float SCS(dot)(const scs_float *x, const scs_float *y, scs_int len) {
 
 /* ||v||_2^2 */
 scs_float SCS(norm_sq)(const scs_float *v, scs_int len) {
-  scs_float nrm = SCS(norm_2)(v, len);
-  return nrm * nrm;
+  blas_int bone = 1;
+  blas_int blen = (blas_int)len;
+  return BLAS(dot)(&blen, v, &bone, v, &bone);
 }
 
 /* ||v||_2 */
@@ -163,6 +170,18 @@ scs_float SCS(norm_inf)(const scs_float *a, scs_int len) {
   if (len <= 0) {
     return 0.0;
   }
+  /* For short vectors the BLAS function-call overhead (pointer args,
+   * Fortran ABI, 1-based index return) exceeds the arithmetic cost.
+   * Use a scalar loop below a threshold. */
+  if (len <= 16) {
+    scs_float mx = 0.0, tmp;
+    scs_int i;
+    for (i = 0; i < len; ++i) {
+      tmp = ABS(a[i]);
+      if (tmp > mx) mx = tmp;
+    }
+    return mx;
+  }
   idx = (scs_int)BLASI(amax)(&blen, a, &bone);
   /* Returned idx is 1-based. */
   return ABS(a[idx - 1]);

data/vendor/scs/src/normalize.c

@@ -1,3 +1,9 @@
+/*
+ * Problem data normalization (equilibration) of b and c vectors,
+ * and solution normalization/un-normalization routines.
+ * Matrix normalization (A, P) is in linsys/scs_matrix.c.
+ */
+
 #include "normalize.h"
 
 #include "linalg.h"
@@ -37,13 +43,22 @@ void SCS(normalize_b_c)(ScsScaling *scal, scs_float *b, scs_float *c) {
     b[i] *= scal->D[i];
   }
 
-  /* calculate primal and dual scales */
-  nm_c = SCS(norm_inf)(c, scal->n);
-  nm_b = SCS(norm_inf)(b, scal->m);
-  sigma = MAX(nm_c, nm_b);
-  sigma = sigma < MIN_NORMALIZATION_FACTOR ? 1.0 : sigma;
-  sigma = sigma > MAX_NORMALIZATION_FACTOR ? MAX_NORMALIZATION_FACTOR : sigma;
-  sigma = SAFEDIV_POS(1.0, sigma);
+  /* sigma comes from the stacked-operator equilibration (the tau-slot
+   * scaling computed jointly with D, E by normalize_a_p), replacing the
+   * old one-shot clamped max-norm heuristic which left problems with
+   * extreme cost/rhs magnitudes badly imbalanced. Fall back to the
+   * heuristic if unset (defensive; normalize_a_p always sets it). */
+  if (scal->tau_scale > 0.) {
+    sigma = scal->tau_scale;
+  } else {
+    nm_c = SCS(norm_inf)(c, scal->n);
+    nm_b = SCS(norm_inf)(b, scal->m);
+    sigma = MAX(nm_c, nm_b);
+    sigma = sigma < MIN_NORMALIZATION_FACTOR ? 1.0 : sigma;
+    sigma =
+        sigma > MAX_NORMALIZATION_FACTOR ? MAX_NORMALIZATION_FACTOR : sigma;
+    sigma = SAFEDIV_POS(1.0, sigma);
+  }
 
   /* Scale b, c */
   SCS(scale_array)(c, sigma, scal->n);
@@ -62,10 +77,9 @@ void SCS(normalize_sol)(ScsScaling *scal, ScsSolution *sol) {
   for (i = 0; i < scal->n; ++i) {
     sol->x[i] /= (E[i] / scal->dual_scale);
   }
+  /* Fuse the y and s loops: both index D[i], halving D reads. */
   for (i = 0; i < scal->m; ++i) {
     sol->y[i] /= (D[i] / scal->primal_scale);
-  }
-  for (i = 0; i < scal->m; ++i) {
     sol->s[i] *= (D[i] * scal->dual_scale);
   }
 }
@@ -77,26 +91,10 @@ void SCS(un_normalize_sol)(ScsScaling *scal, ScsSolution *sol) {
   for (i = 0; i < scal->n; ++i) {
     sol->x[i] *= (E[i] / scal->dual_scale);
   }
+  /* Fuse the y and s loops: both index D[i], halving D reads. */
   for (i = 0; i < scal->m; ++i) {
     sol->y[i] *= (D[i] / scal->primal_scale);
-  }
-  for (i = 0; i < scal->m; ++i) {
     sol->s[i] /= (D[i] * scal->dual_scale);
   }
 }
 
-void SCS(un_normalize_primal)(ScsScaling *scal, scs_float *r) {
-  scs_int i;
-  scs_float *D = scal->D;
-  for (i = 0; i < scal->m; ++i) {
-    r[i] /= (D[i] * scal->dual_scale);
-  }
-}
-
-void SCS(un_normalize_dual)(ScsScaling *scal, scs_float *r) {
-  scs_int i;
-  scs_float *E = scal->E;
-  for (i = 0; i < scal->n; ++i) {
-    r[i] /= (E[i] * scal->primal_scale);
-  }
-}