scs 0.5.3 → 0.5.4

data/vendor/scs/src/exp_cone.c

@@ -6,11 +6,9 @@
 #define EXP_CONE_INFINITY_VALUE (1E15)
 
 /*
- * Exponential cone projection routines, from:
- *
- * Projection onto the exponential cone: a univariate root-finding problem,
- *    by Henrik A. Friberg, 2021.
- *
+ * Exponential cone projection routines, based on:
+ * "Projection onto the exponential cone: a univariate root-finding problem"
+ * by Henrik A. Friberg, 2021.
  */
 
 static inline scs_int _isfinite(scs_float x) {
@@ -21,16 +19,24 @@ static inline scs_float _clip(scs_float x, scs_float l, scs_float u) {
   return MAX(l, MIN(u, x));
 }
 
+static inline void _copy(scs_float *dest, const scs_float *src) {
+  dest[0] = src[0];
+  dest[1] = src[1];
+  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) {
   scs_float t0 = v0[2], s0 = v0[1], r0 = v0[0];
-  scs_float exprho = exp(rho);
-  scs_float expnegrho = exp(-rho);
-  /* function value at v0 */
+  scs_float exprho = EXPF(rho);
+  scs_float expnegrho = EXPF(-rho);
+
+  /* Function value at v0 */
   *f = ((rho - 1) * r0 + s0) * exprho - (r0 - rho * s0) * expnegrho -
        (rho * (rho - 1) + 1) * t0;
-  /* gradient of function at v0 */
+
+  /* Gradient of function at v0 */
   *df = (rho * r0 + s0) * exprho + (r0 - (rho - 1) * s0) * expnegrho -
         (2 * rho - 1) * t0;
 }
@@ -38,23 +44,28 @@ static void hfun(const scs_float *v0, scs_float rho, scs_float *f,
 /* Binary search for the root of the hfun function */
 static scs_float root_search_binary(const scs_float *v0, scs_float xl,
                                     scs_float xu, scs_float x) {
-#if VERBOSITY > 0
-  scs_printf("Exp cone: Newton method failed, resorting to binary search.\n");
-#endif
-  const scs_float EPS = 1e-12; /* expensive so loosen tol */
+  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;
+
+#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);
+
     if (f < 0.0) {
       xl = x;
     } else {
       xu = x;
     }
-    /* binary search step */
+
+    /* Binary search step */
     x_plus = 0.5 * (xl + xu);
-    if (ABS(x_plus - x) <= EPS * MAX(1., ABS(x_plus)) || (x_plus == xl) ||
+
+    if (ABS(x_plus - x) <= EPS * MAX(1.0, ABS(x_plus)) || (x_plus == xl) ||
         (x_plus == xu)) {
       break;
     }
@@ -63,10 +74,10 @@ static scs_float root_search_binary(const scs_float *v0, scs_float xl,
   return x_plus;
 }
 
-/* Use damped Newton's to find the root of the hfun function */
+/* Use damped Newton's method to find the root of the hfun function */
 static scs_float root_search_newton(const scs_float *v0, scs_float xl,
                                     scs_float xu, scs_float x) {
-  /* params taken from Friberg code */
+  /* Paraameters taken from Friberg code. */
   const scs_float EPS = 1e-15;
   const scs_float DFTOL = 1e-13; /* pow(EPS, 6.0 / 7.0) */
   const scs_int MAXITER = 20;
@@ -83,18 +94,21 @@ static scs_float root_search_newton(const scs_float *v0, scs_float xl,
       break;
     }
 
+    /* Update bounds */
     if (f < 0.0) {
       xl = x;
     } else {
       xu = x;
     }
 
+    /* If bracket collapsed */
     if (xu <= xl) {
       xu = 0.5 * (xu + xl);
       xl = xu;
       break;
     }
 
+    /* Check for flat gradient or infinity */
     if (!_isfinite(f) || df < DFTOL) {
       break;
     }
@@ -102,10 +116,11 @@ static scs_float root_search_newton(const scs_float *v0, scs_float xl,
     /* Newton step */
     x_plus = x - f / df;
 
-    if (ABS(x_plus - x) <= EPS * MAX(1., ABS(x_plus))) {
+    if (ABS(x_plus - x) <= EPS * MAX(1.0, ABS(x_plus))) {
       break;
     }
 
+    /* Damped update with projection onto bounds */
     if (x_plus >= xu) {
       x = MIN(LODAMP * x + HIDAMP * xu, xu);
     } else if (x_plus <= xl) {
@@ -114,30 +129,33 @@ static scs_float root_search_newton(const scs_float *v0, scs_float xl,
       x = x_plus;
     }
   }
+
   if (i < MAXITER) { /* Newton's method converged */
 #if VERBOSITY > 0
     scs_printf("Exp cone: Newton iters:%i, f:%.4e, df:%.4e\n", (int)i, f, df);
 #endif
     return _clip(x, xl, xu);
   }
+
   /* Fall back to binary search if Newton failed */
   return root_search_binary(v0, xl, xu, x);
 }
 
-/* try heuristic (cheap) projection */
+/* Try heuristic (cheap) projection for primal cone */
 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;
-  /* perspective boundary */
-  vp[2] = MAX(t0, 0);
+
+  /* Perspective boundary */
+  vp[2] = MAX(t0, 0.0);
   vp[1] = 0.0;
-  vp[0] = MIN(r0, 0);
+  vp[0] = MIN(r0, 0.0);
   dist = SCS(norm_diff)(v0, vp, 3);
 
-  /* perspective interior */
+  /* Perspective interior */
   if (s0 > 0.0) {
-    tp = MAX(t0, s0 * exp(r0 / s0));
+    tp = MAX(t0, s0 * EXPF(r0 / s0));
     newdist = tp - t0;
     if (newdist < dist) {
       vp[2] = tp;
@@ -149,20 +167,21 @@ static scs_float proj_primal_exp_cone_heuristic(const scs_float *v0,
   return dist;
 }
 
-/* try heuristic (cheap) projection */
+/* 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;
-  /* perspective boundary */
-  vd[2] = MIN(t0, 0);
-  vd[1] = MIN(s0, 0);
+
+  /* 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);
 
-  /* perspective interior */
+  /* Perspective interior */
   if (r0 > 0.0) {
-    td = MIN(t0, -r0 * exp(s0 / r0 - 1));
+    td = MIN(t0, -r0 * EXPF(s0 / r0 - 1.0));
     newdist = t0 - td;
     if (newdist < dist) {
       vd[2] = td;
@@ -179,21 +198,20 @@ static scs_float ppsi(const scs_float *v0) {
   scs_float psi;
 
   if (r0 > s0) {
-    psi = (r0 - s0 + sqrt(r0 * r0 + s0 * s0 - r0 * s0)) / r0;
+    psi = (r0 - s0 + SQRTF(r0 * r0 + s0 * s0 - r0 * s0)) / r0;
   } else {
-    psi = -s0 / (r0 - s0 - sqrt(r0 * r0 + s0 * s0 - r0 * s0));
+    psi = -s0 / (r0 - s0 - SQRTF(r0 * r0 + s0 * s0 - r0 * s0));
   }
 
-  return ((psi - 1) * r0 + s0) / (psi * (psi - 1) + 1);
+  return ((psi - 1.0) * r0 + s0) / (psi * (psi - 1.0) + 1.0);
 }
 
 static scs_float pomega(scs_float rho) {
-  scs_float val = exp(rho) / (rho * (rho - 1) + 1);
+  scs_float val = EXPF(rho) / (rho * (rho - 1.0) + 1.0);
 
   if (rho < 2.0) {
-    val = MIN(val, exp(2.0) / 3);
+    val = MIN(val, EXPF(2.0) / 3.0);
   }
-
   return val;
 }
 
@@ -202,21 +220,20 @@ static scs_float dpsi(const scs_float *v0) {
   scs_float psi;
 
   if (s0 > r0) {
-    psi = (r0 - sqrt(r0 * r0 + s0 * s0 - r0 * s0)) / s0;
+    psi = (r0 - SQRTF(r0 * r0 + s0 * s0 - r0 * s0)) / s0;
   } else {
-    psi = (r0 - s0) / (r0 + sqrt(r0 * r0 + s0 * s0 - r0 * s0));
+    psi = (r0 - s0) / (r0 + SQRTF(r0 * r0 + s0 * s0 - r0 * s0));
   }
 
-  return (r0 - psi * s0) / (psi * (psi - 1) + 1);
+  return (r0 - psi * s0) / (psi * (psi - 1.0) + 1.0);
 }
 
 static scs_float domega(scs_float rho) {
-  scs_float val = -exp(-rho) / (rho * (rho - 1) + 1);
+  scs_float val = -EXPF(-rho) / (rho * (rho - 1.0) + 1.0);
 
   if (rho > -1.0) {
-    val = MAX(val, -exp(1.0) / 3);
+    val = MAX(val, -EXPF(1.0) / 3.0);
   }
-
   return val;
 }
 
@@ -225,41 +242,46 @@ static void exp_search_bracket(const scs_float *v0, scs_float pdist,
                                scs_float ddist, 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,
-            baseupr = EXP_CONE_INFINITY_VALUE;
-  scs_float low = -EXP_CONE_INFINITY_VALUE, upr = EXP_CONE_INFINITY_VALUE;
-
-  scs_float Dp = SQRTF(pdist * pdist - MIN(s0, 0) * MIN(s0, 0));
-  scs_float Dd = SQRTF(ddist * ddist - MIN(r0, 0) * MIN(r0, 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 curbnd, fl, fu, df, tpu, tdl;
+  Dp = SQRTF(pdist * pdist - MIN(s0, 0.0) * MIN(s0, 0.0));
+  Dd = SQRTF(ddist * ddist - MIN(r0, 0.0) * MIN(r0, 0.0));
 
-  if (t0 > 0) {
-    curbnd = log(t0 / ppsi(v0));
+  if (t0 > 0.0) {
+    curbnd = LOGF(t0 / ppsi(v0));
     low = MAX(low, curbnd);
-  } else if (t0 < 0) {
-    curbnd = -log(-t0 / dpsi(v0));
+  } else if (t0 < 0.0) {
+    curbnd = -LOGF(-t0 / dpsi(v0));
     upr = MIN(upr, curbnd);
   }
 
-  if (r0 > 0) {
-    baselow = 1 - s0 / r0;
+  if (r0 > 0.0) {
+    baselow = 1.0 - s0 / r0;
     low = MAX(low, baselow);
     tpu = MAX(1e-12, MIN(Dd, Dp + t0));
-    curbnd = MAX(low, baselow + tpu / r0 / pomega(low));
+    val = r0 * pomega(low);
+    sgn = val < 0 ? -1 : 1;
+    curbnd = MAX(low, baselow + SAFEDIV_POS(tpu, ABS(val)) * sgn);
     upr = MIN(upr, curbnd);
   }
 
-  if (s0 > 0) {
+  if (s0 > 0.0) {
     baseupr = r0 / s0;
     upr = MIN(upr, baseupr);
     tdl = -MAX(1e-12, MIN(Dp, Dd - t0));
-    curbnd = MIN(upr, baseupr - tdl / s0 / domega(upr));
+    val = s0 * domega(upr);
+    sgn = val < 0 ? -1 : 1;
+    curbnd = MIN(upr, baseupr - SAFEDIV_POS(tdl, ABS(val)) * sgn);
     low = MAX(low, curbnd);
   }
 
-  /* Guarantee valid bracket */
-  /* TODO do we need these 2 lines? */
+  /* Guarantee valid bracket. Floating point errors can push bounds
+   * slightly outside base interval or flip low/upr.
+   */
   low = _clip(MIN(low, upr), baselow, baseupr);
   upr = _clip(MAX(low, upr), baselow, baseupr);
 
@@ -267,7 +289,7 @@ static void exp_search_bracket(const scs_float *v0, scs_float pdist,
     hfun(v0, low, &fl, &df);
     hfun(v0, upr, &fu, &df);
 
-    if (fl * fu > 0) {
+    if (fl * fu > 0.0) {
       if (ABS(fl) < ABS(fu)) {
         upr = low;
       } else {
@@ -283,11 +305,12 @@ static void exp_search_bracket(const scs_float *v0, scs_float pdist,
 /* convert from rho to primal projection */
 static scs_float proj_sol_primal_exp_cone(const scs_float *v0, scs_float rho,
                                           scs_float *vp) {
-  scs_float linrho = (rho - 1) * v0[0] + v0[1];
-  scs_float exprho = exp(rho);
+  scs_float linrho = (rho - 1.0) * v0[0] + v0[1];
+  scs_float exprho = EXPF(rho);
   scs_float quadrho, dist;
-  if (linrho > 0 && _isfinite(exprho)) {
-    quadrho = rho * (rho - 1) + 1;
+
+  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;
@@ -305,12 +328,13 @@ static scs_float proj_sol_primal_exp_cone(const scs_float *v0, scs_float rho,
 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 = exp(-rho);
+  scs_float exprho = EXPF(-rho);
   scs_float quadrho, dist;
-  if (linrho > 0 && _isfinite(exprho)) {
-    quadrho = rho * (rho - 1) + 1;
+
+  if (linrho > 0.0 && _isfinite(exprho)) {
+    quadrho = rho * (rho - 1.0) + 1.0;
     vd[2] = -exprho * linrho / quadrho;
-    vd[1] = (1 - rho) * linrho / quadrho;
+    vd[1] = (1.0 - rho) * linrho / quadrho;
     vd[0] = linrho / quadrho;
     dist = SCS(norm_diff)(v0, vd, 3);
   } else {
@@ -322,12 +346,6 @@ static scs_float proj_sol_polar_exp_cone(const scs_float *v0, scs_float rho,
   return dist;
 }
 
-static inline void _copy(scs_float *dest, scs_float *src) {
-  dest[0] = src[0];
-  dest[1] = src[1];
-  dest[2] = src[2];
-}
-
 /* Project onto primal or dual exponential cone, performed in-place.
  * If `primal=0` then project on the dual cone, otherwise project
  * onto primal. Taken from algorithm in Friberg, 2021.
@@ -337,14 +355,15 @@ scs_float SCS(proj_pd_exp_cone)(scs_float *v0, scs_int primal) {
   scs_float xl, xh, pdist, ddist, err, rho, dist_hat;
   scs_float vp[3], vd[3], v_hat[3];
   scs_int opt;
+
   if (!primal) {
     /* This routine actually projects onto primal and polar cones
      * simultaneously. So to make it project onto dual, use this:
      * Pi_{C^*}(v0) = -Pi_{C^polar}(-v0)
      */
-    v0[0] *= -1.;
-    v0[1] *= -1.;
-    v0[2] *= -1.;
+    v0[0] *= -1.0;
+    v0[1] *= -1.0;
+    v0[2] *= -1.0;
   }
 
   pdist = proj_primal_exp_cone_heuristic(v0, vp);
@@ -357,15 +376,16 @@ scs_float SCS(proj_pd_exp_cone)(scs_float *v0, scs_int primal) {
   /* Skip root search if presolve rules apply
    * or optimality conditions are satisfied
    */
-  opt = (v0[1] <= 0 && v0[0] <= 0);
+  opt = (v0[1] <= 0.0 && v0[0] <= 0.0);
   opt |= (MIN(pdist, ddist) <= TOL);
   opt |= (err <= TOL && SCS(dot)(vp, vd, 3) <= TOL);
+
   if (opt) {
     if (primal) {
       _copy(v0, vp);
       return pdist;
     }
-    /* polar cone -> dual cone */
+    /* Polar cone -> dual cone. */
     v0[0] = -vd[0];
     v0[1] = -vd[1];
     v0[2] = -vd[2];
@@ -376,7 +396,7 @@ scs_float SCS(proj_pd_exp_cone)(scs_float *v0, scs_int primal) {
   rho = root_search_newton(v0, xl, xh, 0.5 * (xl + xh));
 
   if (primal) {
-    /* primal cone projection */
+    /* Primal cone projection. */
     dist_hat = proj_sol_primal_exp_cone(v0, rho, v_hat);
     if (dist_hat <= pdist) {
       _copy(vp, v_hat);
@@ -385,13 +405,15 @@ scs_float SCS(proj_pd_exp_cone)(scs_float *v0, scs_int primal) {
     _copy(v0, vp);
     return pdist;
   }
-  /* polar cone projection */
+
+  /* Polar cone projection. */
   dist_hat = proj_sol_polar_exp_cone(v0, rho, v_hat);
   if (dist_hat <= ddist) {
     _copy(vd, v_hat);
     ddist = dist_hat;
   }
-  /* polar cone -> dual cone */
+
+  /* Polar cone -> dual cone. */
   v0[0] = -vd[0];
   v0[1] = -vd[1];
   v0[2] = -vd[2];

data/vendor/scs/src/linalg.c

@@ -86,6 +86,9 @@ void SCS(add_scaled_array)(scs_float *a, const scs_float *b, scs_int n,
 scs_float SCS(mean)(const scs_float *x, scs_int n) {
   scs_int i;
   scs_float mean = 0.;
+  if (n == 0) {
+    return 0.;
+  }
   for (i = 0; i < n; ++i) {
     mean += x[i];
   }
@@ -178,6 +181,9 @@ scs_float SCS(mean)(const scs_float *x, scs_int n) {
   blas_int bzero = 0;
   blas_int blen = (blas_int)n;
   scs_float y = 1.0;
+  if (n == 0) {
+    return 0.;
+  }
   return BLAS(dot)(&blen, x, &bone, &y, &bzero) / n;
 }
 

data/vendor/scs/src/scs.c

@@ -900,7 +900,7 @@ static ScsWork *init_work(const ScsData *d, const ScsCone *k,
   }
   if (w->stgs->acceleration_lookback) {
     /* TODO(HACK!) negative acceleration_lookback interpreted as type-II */
-    if (!(w->accel = aa_init(l, ABS(w->stgs->acceleration_lookback),
+    if (!(w->accel = aa_init(l, abs(w->stgs->acceleration_lookback),
                              w->stgs->acceleration_lookback > 0,
                              w->stgs->acceleration_lookback > 0
                                  ? AA_REGULARIZATION_TYPE_1

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: scs
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 0.5.4
 platform: ruby
 authors:
 - Andrew Kane
@@ -169,7 +169,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.3
 specification_version: 4
 summary: SCS - the splitting conic solver - for Ruby
 test_files: []