scs 0.4.0 → 0.4.2

data/vendor/scs/src/cones.c

@@ -4,10 +4,8 @@
 #include "scs_blas.h" /* contains BLAS(X) macros and type info */
 #include "util.h"
 
-#define CONE_TOL (1e-9)
-#define CONE_THRESH (1e-8)
-#define EXP_CONE_MAX_ITERS (100)
 #define BOX_CONE_MAX_ITERS (25)
+#define POW_CONE_TOL (1e-9)
 #define POW_CONE_MAX_ITERS (20)
 
 /* Box cone limits (+ or -) taken to be INF */
@@ -35,6 +33,11 @@ void BLAS(scal)(const blas_int *n, const scs_float *sa, scs_float *sx,
 
 #endif
 
+/* Forward declare exponential cone projection routine.
+ * Implemented in exp_cone.c.
+ */
+scs_float SCS(proj_pd_exp_cone)(scs_float *v0, scs_int primal);
+
 void SCS(free_cone)(ScsCone *k) {
   if (k) {
     if (k->bu)
@@ -285,7 +288,7 @@ void SCS(finish_cone)(ScsConeWork *c) {
 }
 
 char *SCS(get_cone_header)(const ScsCone *k) {
-  char *tmp = (char *)scs_malloc(sizeof(char) * 512);
+  char *tmp = (char *)scs_malloc(512); /* sizeof(char) = 1 */
   scs_int i, soc_vars, sd_vars;
   sprintf(tmp, "cones: ");
   if (k->z) {
@@ -325,122 +328,10 @@ char *SCS(get_cone_header)(const ScsCone *k) {
   return tmp;
 }
 
-static scs_float exp_newton_one_d(scs_float rho, scs_float y_hat,
-                                  scs_float z_hat, scs_float w) {
-  scs_float t_prev, t = MAX(w - z_hat, MAX(-z_hat, 1e-9));
-  scs_float f = 1., fp = 1.;
-  scs_int i;
-  for (i = 0; i < EXP_CONE_MAX_ITERS; ++i) {
-    t_prev = t;
-    f = t * (t + z_hat) / rho / rho - y_hat / rho + log(t / rho) + 1;
-    fp = (2 * t + z_hat) / rho / rho + 1 / t;
-
-    t = t - f / fp;
-
-    if (t <= -z_hat) {
-      t = -z_hat;
-      break;
-    } else if (t <= 0) {
-      t = 0;
-      break;
-    } else if (ABS(t - t_prev) < CONE_TOL) {
-      break;
-    } else if (SQRTF(f * f / fp) < CONE_TOL) {
-      break;
-    }
-  }
-  if (i == EXP_CONE_MAX_ITERS) {
-    scs_printf("warning: exp cone newton step hit maximum %i iters\n", (int)i);
-    scs_printf("rho=%1.5e; y_hat=%1.5e; z_hat=%1.5e; w=%1.5e; f=%1.5e, "
-               "fp=%1.5e, t=%1.5e, t_prev= %1.5e\n",
-               rho, y_hat, z_hat, w, f, fp, t, t_prev);
-  }
-  return t + z_hat;
-}
-
-static void exp_solve_for_x_with_rho(const scs_float *v, scs_float *x,
-                                     scs_float rho, scs_float w) {
-  x[2] = exp_newton_one_d(rho, v[1], v[2], w);
-  x[1] = (x[2] - v[2]) * x[2] / rho;
-  x[0] = v[0] - rho;
-}
-
-static scs_float exp_calc_grad(const scs_float *v, scs_float *x, scs_float rho,
-                               scs_float w) {
-  exp_solve_for_x_with_rho(v, x, rho, w);
-  if (x[1] <= 1e-12) {
-    return x[0];
-  }
-  return x[0] + x[1] * log(x[1] / x[2]);
-}
-
-static void exp_get_rho_ub(const scs_float *v, scs_float *x, scs_float *ub,
-                           scs_float *lb) {
-  *lb = 0;
-  *ub = 0.125;
-  while (exp_calc_grad(v, x, *ub, v[1]) > 0) {
-    *lb = *ub;
-    (*ub) *= 2;
-  }
-}
-
-/* project onto the exponential cone, v has dimension *exactly* 3 */
-static scs_int proj_exp_cone(scs_float *v) {
-  scs_int i;
-  scs_float ub, lb, rho, g, x[3];
-  scs_float r = v[0], s = v[1], t = v[2];
-
-  /* v in cl(Kexp) */
-  if ((s * exp(r / s) - t <= CONE_THRESH && s > 0) ||
-      (r <= 0 && s == 0 && t >= 0)) {
-    return 0;
-  }
-
-  /* -v in Kexp^* */
-  if ((r > 0 && r * exp(s / r) + exp(1) * t <= CONE_THRESH) ||
-      (r == 0 && s <= 0 && t <= 0)) {
-    memset(v, 0, 3 * sizeof(scs_float));
-    return 0;
-  }
-
-  /* special case with analytical solution */
-  if (r < 0 && s < 0) {
-    v[1] = 0.0;
-    v[2] = MAX(v[2], 0);
-    return 0;
-  }
-
-  /* iterative procedure to find projection, bisects on dual variable: */
-  exp_get_rho_ub(v, x, &ub, &lb); /* get starting upper and lower bounds */
-  for (i = 0; i < EXP_CONE_MAX_ITERS; ++i) {
-    rho = (ub + lb) / 2; /* halfway between upper and lower bounds */
-    g = exp_calc_grad(v, x, rho, x[1]); /* calculates gradient wrt dual var */
-    if (g > 0) {
-      lb = rho;
-    } else {
-      ub = rho;
-    }
-    if (ub - lb < CONE_TOL) {
-      break;
-    }
-  }
-#if VERBOSITY > 10
-  scs_printf("exponential cone proj iters %i\n", (int)i);
-#endif
-  if (i == EXP_CONE_MAX_ITERS) {
-    scs_printf("warning: exp cone outer step hit maximum %i iters\n", (int)i);
-    scs_printf("r=%1.5e; s=%1.5e; t=%1.5e\n", r, s, t);
-  }
-  v[0] = x[0];
-  v[1] = x[1];
-  v[2] = x[2];
-  return 0;
-}
-
 static scs_int set_up_sd_cone_work_space(ScsConeWork *c, const ScsCone *k) {
   scs_int i;
 #ifdef USE_LAPACK
-  blas_int n_max = 0;
+  blas_int n_max = 1;
   blas_int neg_one = -1;
   blas_int info = 0;
   scs_float wkopt = 0.0;
@@ -465,7 +356,7 @@ static scs_int set_up_sd_cone_work_space(ScsConeWork *c, const ScsCone *k) {
    &info);
 
   if (info != 0) {
-    scs_printf("FATAL: syev failure, info = %li\n", (long)info);
+    scs_printf("FATAL: syev workspace query failure, info = %li\n", (long)info);
     return -1;
   }
   c->lwork = (blas_int)(wkopt + 1); /* +1 for int casting safety */
@@ -741,13 +632,13 @@ static void proj_power_cone(scs_float *v, scs_float a) {
   scs_int i;
   /* v in K_a */
   if (xh >= 0 && yh >= 0 &&
-      CONE_THRESH + POWF(xh, a) * POWF(yh, (1 - a)) >= rh) {
+      POW_CONE_TOL + POWF(xh, a) * POWF(yh, (1 - a)) >= rh) {
     return;
   }
 
   /* -v in K_a^* */
   if (xh <= 0 && yh <= 0 &&
-      CONE_THRESH + POWF(-xh, a) * POWF(-yh, 1 - a) >=
+      POW_CONE_TOL + POWF(-xh, a) * POWF(-yh, 1 - a) >=
           rh * POWF(a, a) * POWF(1 - a, 1 - a)) {
     v[0] = v[1] = v[2] = 0;
     return;
@@ -760,7 +651,7 @@ static void proj_power_cone(scs_float *v, scs_float a) {
     y = pow_calc_x(r, yh, rh, 1 - a);
 
     f = pow_calc_f(x, y, r, a);
-    if (ABS(f) < CONE_TOL) {
+    if (ABS(f) < POW_CONE_TOL) {
       break;
     }
 
@@ -829,51 +720,16 @@ static scs_int proj_cone(scs_float *x, const ScsCone *k, ScsConeWork *c,
     }
   }
 
-  if (k->ep) { /* doesn't use r_y */
-               /*
-                * exponential cone is not self dual, if s \in K
-                * then y \in K^* and so if K is the primal cone
-                * here we project onto K^*, via Moreau
-                * \Pi_C^*(y) = y + \Pi_C(-y)
-                */
+  if (k->ep || k->ed) { /* doesn't use r_y */
 #ifdef _OPENMP
 #pragma omp parallel for
 #endif
-    for (i = 0; i < k->ep; ++i) {
-      proj_exp_cone(&(x[count + 3 * i]));
+    for (i = 0; i < k->ep + k->ed; ++i) {
+      /* provided in exp_cone.c */
+      SCS(proj_pd_exp_cone)(&(x[count + 3 * i]), i < k->ep);
     }
-    count += 3 * k->ep;
+    count += 3 * (k->ep + k->ed);
   }
-
-  /* dual exponential cone */
-  if (k->ed) { /* doesn't use r_y */
-    /*
-     * exponential cone is not self dual, if s \in K
-     * then y \in K^* and so if K is the primal cone
-     * here we project onto K^*, via Moreau
-     * \Pi_C^*(y) = y + \Pi_C(-y)
-     */
-    scs_int idx;
-    scs_float r, s, t;
-    SCS(scale_array)(&(x[count]), -1, 3 * k->ed); /* x = -x; */
-#ifdef _OPENMP
-#pragma omp parallel for private(r, s, t, idx)
-#endif
-    for (i = 0; i < k->ed; ++i) {
-      idx = count + 3 * i;
-      r = x[idx];
-      s = x[idx + 1];
-      t = x[idx + 2];
-
-      proj_exp_cone(&(x[idx]));
-
-      x[idx] -= r;
-      x[idx + 1] -= s;
-      x[idx + 2] -= t;
-    }
-    count += 3 * k->ed;
-  }
-
   if (k->psize && k->p) { /* doesn't use r_y */
     scs_float v[3];
     scs_int idx;

data/vendor/scs/src/exp_cone.c

@@ -0,0 +1,399 @@
+#include "cones.h"
+#include "glbopts.h"
+#include "linalg.h"
+#include "scs.h"
+
+#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.
+ *
+ */
+
+static inline scs_int _isfinite(scs_float x) {
+  return ABS(x) < EXP_CONE_INFINITY_VALUE;
+}
+
+static inline scs_float _clip(scs_float x, scs_float l, scs_float u) {
+  return MAX(l, MIN(u, x));
+}
+
+/* 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 */
+  *f = ((rho - 1) * r0 + s0) * exprho - (r0 - rho * s0) * expnegrho -
+       (rho * (rho - 1) + 1) * t0;
+  /* gradient of function at v0 */
+  *df = (rho * r0 + s0) * exprho + (r0 - (rho - 1) * s0) * expnegrho -
+        (2 * rho - 1) * t0;
+}
+
+/* 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_int MAXITER = 40;
+  scs_int i;
+  scs_float x_plus = x, f, df;
+  for (i = 0; i < MAXITER; i++) {
+    hfun(v0, x, &f, &df);
+    if (f < 0.0) {
+      xl = x;
+    } else {
+      xu = x;
+    }
+    /* binary search step */
+    x_plus = 0.5 * (xl + xu);
+    if (ABS(x_plus - x) <= EPS * MAX(1., ABS(x_plus)) || (x_plus == xl) ||
+        (x_plus == xu)) {
+      break;
+    }
+    x = x_plus;
+  }
+  return x_plus;
+}
+
+/* Use damped Newton's 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 */
+  const scs_float EPS = 1e-15;
+  const scs_float DFTOL = 1e-13; /* pow(EPS, 6.0 / 7.0) */
+  const scs_int MAXITER = 20;
+  const scs_float LODAMP = 0.05;
+  const scs_float HIDAMP = 0.95;
+
+  scs_float x_plus, f, df;
+  scs_int i;
+
+  for (i = 0; i < MAXITER; i++) {
+    hfun(v0, x, &f, &df);
+
+    if (ABS(f) <= EPS) { /* root found */
+      break;
+    }
+
+    if (f < 0.0) {
+      xl = x;
+    } else {
+      xu = x;
+    }
+
+    if (xu <= xl) {
+      xu = 0.5 * (xu + xl);
+      xl = xu;
+      break;
+    }
+
+    if (!_isfinite(f) || df < DFTOL) {
+      break;
+    }
+
+    /* Newton step */
+    x_plus = x - f / df;
+
+    if (ABS(x_plus - x) <= EPS * MAX(1., ABS(x_plus))) {
+      break;
+    }
+
+    if (x_plus >= xu) {
+      x = MIN(LODAMP * x + HIDAMP * xu, xu);
+    } else if (x_plus <= xl) {
+      x = MAX(LODAMP * x + HIDAMP * xl, xl);
+    } else {
+      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 */
+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);
+  vp[1] = 0.0;
+  vp[0] = MIN(r0, 0);
+  dist = SCS(norm_diff)(v0, vp, 3);
+
+  /* perspective interior */
+  if (s0 > 0.0) {
+    tp = MAX(t0, s0 * exp(r0 / s0));
+    newdist = tp - t0;
+    if (newdist < dist) {
+      vp[2] = tp;
+      vp[1] = s0;
+      vp[0] = r0;
+      dist = newdist;
+    }
+  }
+  return dist;
+}
+
+/* try heuristic (cheap) projection */
+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);
+  vd[0] = 0.0;
+  dist = SCS(norm_diff)(v0, vd, 3);
+
+  /* perspective interior */
+  if (r0 > 0.0) {
+    td = MIN(t0, -r0 * exp(s0 / r0 - 1));
+    newdist = t0 - td;
+    if (newdist < dist) {
+      vd[2] = td;
+      vd[1] = s0;
+      vd[0] = r0;
+      dist = newdist;
+    }
+  }
+  return dist;
+}
+
+static scs_float ppsi(const scs_float *v0) {
+  scs_float s0 = v0[1], r0 = v0[0];
+  scs_float psi;
+
+  if (r0 > s0) {
+    psi = (r0 - s0 + sqrt(r0 * r0 + s0 * s0 - r0 * s0)) / r0;
+  } else {
+    psi = -s0 / (r0 - s0 - sqrt(r0 * r0 + s0 * s0 - r0 * s0));
+  }
+
+  return ((psi - 1) * r0 + s0) / (psi * (psi - 1) + 1);
+}
+
+static scs_float pomega(scs_float rho) {
+  scs_float val = exp(rho) / (rho * (rho - 1) + 1);
+
+  if (rho < 2.0) {
+    val = MIN(val, exp(2.0) / 3);
+  }
+
+  return val;
+}
+
+static scs_float dpsi(const scs_float *v0) {
+  scs_float s0 = v0[1], r0 = v0[0];
+  scs_float psi;
+
+  if (s0 > r0) {
+    psi = (r0 - sqrt(r0 * r0 + s0 * s0 - r0 * s0)) / s0;
+  } else {
+    psi = (r0 - s0) / (r0 + sqrt(r0 * r0 + s0 * s0 - r0 * s0));
+  }
+
+  return (r0 - psi * s0) / (psi * (psi - 1) + 1);
+}
+
+static scs_float domega(scs_float rho) {
+  scs_float val = -exp(-rho) / (rho * (rho - 1) + 1);
+
+  if (rho > -1.0) {
+    val = MAX(val, -exp(1.0) / 3);
+  }
+
+  return val;
+}
+
+/* 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,
+                               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 curbnd, fl, fu, df, tpu, tdl;
+
+  if (t0 > 0) {
+    curbnd = log(t0 / ppsi(v0));
+    low = MAX(low, curbnd);
+  } else if (t0 < 0) {
+    curbnd = -log(-t0 / dpsi(v0));
+    upr = MIN(upr, curbnd);
+  }
+
+  if (r0 > 0) {
+    baselow = 1 - s0 / r0;
+    low = MAX(low, baselow);
+    tpu = MAX(1e-12, MIN(Dd, Dp + t0));
+    curbnd = MAX(low, baselow + tpu / r0 / pomega(low));
+    upr = MIN(upr, curbnd);
+  }
+
+  if (s0 > 0) {
+    baseupr = r0 / s0;
+    upr = MIN(upr, baseupr);
+    tdl = -MAX(1e-12, MIN(Dp, Dd - t0));
+    curbnd = MIN(upr, baseupr - tdl / s0 / domega(upr));
+    low = MAX(low, curbnd);
+  }
+
+  /* Guarantee valid bracket */
+  /* TODO do we need these 2 lines? */
+  low = _clip(MIN(low, upr), baselow, baseupr);
+  upr = _clip(MAX(low, upr), baselow, baseupr);
+
+  if (low != upr) {
+    hfun(v0, low, &fl, &df);
+    hfun(v0, upr, &fu, &df);
+
+    if (fl * fu > 0) {
+      if (ABS(fl) < ABS(fu)) {
+        upr = low;
+      } else {
+        low = upr;
+      }
+    }
+  }
+
+  *low_out = low;
+  *upr_out = upr;
+}
+
+/* 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 quadrho, dist;
+  if (linrho > 0 && _isfinite(exprho)) {
+    quadrho = rho * (rho - 1) + 1;
+    vp[2] = exprho * linrho / quadrho;
+    vp[1] = linrho / quadrho;
+    vp[0] = rho * linrho / quadrho;
+    dist = SCS(norm_diff)(vp, v0, 3);
+  } else {
+    vp[2] = EXP_CONE_INFINITY_VALUE;
+    vp[1] = 0.0;
+    vp[0] = 0.0;
+    dist = EXP_CONE_INFINITY_VALUE;
+  }
+  return dist;
+}
+
+/* convert from rho to polar projection */
+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 quadrho, dist;
+  if (linrho > 0 && _isfinite(exprho)) {
+    quadrho = rho * (rho - 1) + 1;
+    vd[2] = -exprho * linrho / quadrho;
+    vd[1] = (1 - rho) * linrho / quadrho;
+    vd[0] = linrho / quadrho;
+    dist = SCS(norm_diff)(v0, vd, 3);
+  } else {
+    vd[2] = -EXP_CONE_INFINITY_VALUE;
+    vd[1] = 0.0;
+    vd[0] = 0.0;
+    dist = EXP_CONE_INFINITY_VALUE;
+  }
+  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.
+ */
+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 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.;
+  }
+
+  pdist = proj_primal_exp_cone_heuristic(v0, vp);
+  ddist = 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]));
+  err = MAX(err, ABS(vp[2] + vd[2] - v0[2]));
+
+  /* Skip root search if presolve rules apply
+   * or optimality conditions are satisfied
+   */
+  opt = (v0[1] <= 0 && v0[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 */
+    v0[0] = -vd[0];
+    v0[1] = -vd[1];
+    v0[2] = -vd[2];
+    return ddist;
+  }
+
+  exp_search_bracket(v0, pdist, ddist, &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) {
+      _copy(vp, v_hat);
+      pdist = dist_hat;
+    }
+    _copy(v0, vp);
+    return pdist;
+  }
+  /* 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 */
+  v0[0] = -vd[0];
+  v0[1] = -vd[1];
+  v0[2] = -vd[2];
+  return ddist;
+}

data/vendor/scs/src/linalg.c

@@ -102,12 +102,16 @@ extern "C" {
 scs_float BLAS(nrm2)(blas_int *n, const scs_float *x, blas_int *incx);
 scs_float BLAS(dot)(const blas_int *n, const scs_float *x, const blas_int *incx,
                     const scs_float *y, const blas_int *incy);
-scs_float BLAS(lange)(const char *norm, const blas_int *m, const blas_int *n,
-                      const scs_float *a, blas_int *lda, scs_float *work);
 void BLAS(axpy)(blas_int *n, const scs_float *a, const scs_float *x,
                 blas_int *incx, scs_float *y, blas_int *incy);
 void BLAS(scal)(const blas_int *n, const scs_float *sa, scs_float *sx,
                 const blas_int *incx);
+blas_int BLASI(amax)(blas_int *n, const scs_float *x, blas_int *incx);
+
+/* Possibly not working correctly on all platforms.
+scs_float BLAS(lange)(const char *norm, const blas_int *m, const blas_int *n,
+                      const scs_float *a, blas_int *lda, scs_float *work);
+*/
 
 #ifdef __cplusplus
 }
@@ -140,10 +144,20 @@ scs_float SCS(norm_2)(const scs_float *v, scs_int len) {
   return BLAS(nrm2)(&blen, v, &bone);
 }
 
+/* Possibly not working correctly on all platforms.
+scs_float SCS(norm_inf)(const scs_float *a, scs_int len) {
+  blas_int bone = 1;
+  blas_int blen = (blas_int)len;
+  return BLAS(lange)("Max", &blen, &bone, a, &blen, SCS_NULL);
+}
+*/
+
 scs_float SCS(norm_inf)(const scs_float *a, scs_int len) {
   blas_int bone = 1;
   blas_int blen = (blas_int)len;
-  return BLAS(lange)("Max", &blen, &bone, a, &bone, SCS_NULL);
+  scs_int idx = (scs_int)BLASI(amax)(&blen, a, &bone);
+  /* Returned idx is 1-based. */
+  return ABS(a[idx - 1]);
 }
 
 /* axpy a += sc*b */

data/vendor/scs/src/normalize.c

@@ -26,7 +26,7 @@
  */
 void SCS(normalize_b_c)(ScsScaling *scal, scs_float *b, scs_float *c) {
   scs_int i;
-  scs_float sigma;
+  scs_float sigma, nm_c, nm_b;
 
   /* scale c */
   for (i = 0; i < scal->n; ++i) {
@@ -38,7 +38,9 @@ void SCS(normalize_b_c)(ScsScaling *scal, scs_float *b, scs_float *c) {
   }
 
   /* calculate primal and dual scales */
-  sigma = MAX(SCS(norm_inf)(c, scal->n), SCS(norm_inf)(b, scal->m));
+  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);