scs 0.5.5 → 0.6.0

data/vendor/scs/src/spectral_cones/logdeterminant/log_cone_IPM.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" // for Newton structs
-#include <string.h>              // for memcpy
+#include "util_spectral_cones.h" /* for Newton structs */
+#include <string.h>              /* for memcpy */
 
 /*
  * Spectral matrix cone projections, from "Projection onto Spectral Matrix
@@ -56,24 +56,29 @@ static void f_oracle(const scs_float *u1, scs_float r, scs_float t0,
                      scs_float v0, const scs_float *x0, const scs_float *x_inv,
                      scs_int n, scs_float *f_u, scs_float *grad_f0,
                      scs_float *grad_f1) {
-  // compute grad_f0[0, 1] = t - t0, v - v0, grad_f1[2:-1] = x - x0
+  scs_float sum_log_xv;
+  scs_float norm_2;
+
+  /* compute grad_f0[0, 1] = t - t0, v - v0, grad_f1[2:-1] = x - x0 */
   grad_f0[0] = u1[0] - t0;
   grad_f0[1] = u1[1] - v0;
   memcpy(grad_f0 + 2, u1 + 2, n * sizeof(*grad_f0));
   SCS(add_scaled_array)(grad_f0 + 2, x0, n, -1.0);
   grad_f0[n + 2] = -1.0;
 
-  // compute f_u
-  scs_float sum_log_xv = sum_log(u1 + 2, n) - n * log(u1[1]);
-  scs_float norm_2 = SCS(norm_2)(grad_f0 + 2, n);
+  /* compute f_u */
+  sum_log_xv = sum_log(u1 + 2, n) - n * log(u1[1]);
+  norm_2 = SCS(norm_2)(grad_f0 + 2, n);
   f_u[0] = 0.5 * (grad_f0[0] * grad_f0[0] + grad_f0[1] * grad_f0[1] +
                   norm_2 * norm_2) -
            r;
   f_u[1] = -u1[1] * sum_log_xv - u1[0];
   f_u[2] = -u1[1];
 
-  // compute grad_f1[0] = -1, grad_f1[1] = n - sum(log(x/v)),
-  // grad[2:-1] = - v / x, grad[-1] = 0
+  /*
+   * compute grad_f1[0] = -1, grad_f1[1] = n - sum(log(x/v)),
+   * grad[2:-1] = - v / x, grad[-1] = 0
+   */
   grad_f1[0] = -1.0;
   grad_f1[1] = n - sum_log_xv;
   memcpy(grad_f1 + 2, x_inv, n * sizeof(*x_inv));
@@ -81,15 +86,17 @@ static void f_oracle(const scs_float *u1, scs_float r, scs_float t0,
   grad_f1[n + 2] = 0.0;
 }
 
-// u1 = [t, v, x]
+/* u1 = [t, v, x] */
 static scs_float find_max_step_size(const scs_float *u1, const scs_float *z,
                                     const scs_float *s, const scs_float *du1,
                                     const scs_float *dz, const scs_float *ds,
                                     scs_int n) {
   scs_float step_max = 10.0;
   scs_int i;
+  scs_float step_max_dom;
+  scs_float step_size;
 
-  // find maximum step size with respect to z and s
+  /* find maximum step size with respect to z and s */
   for (i = 0; i < 3; ++i) {
     if (dz[i] < 0) {
       step_max = MIN(step_max, -z[i] / dz[i]);
@@ -100,16 +107,16 @@ static scs_float find_max_step_size(const scs_float *u1, const scs_float *z,
     }
   }
 
-  scs_float step_max_dom = 10;
+  step_max_dom = 10;
 
-  // find maximum step size with respect to the domain of f
+  /* find maximum step size with respect to the domain of f */
   for (i = 1; i < n + 2; i++) {
     if (du1[i] < 0) {
       step_max_dom = MIN(step_max_dom, -u1[i] / du1[i]);
     }
   }
 
-  scs_float step_size = MIN(1.0, STEP_IPM * step_max);
+  step_size = MIN(1.0, STEP_IPM * step_max);
 
   while (step_size > step_max_dom) {
     step_size *= BETA_IPM;
@@ -135,8 +142,10 @@ typedef struct {
 
 } KKT_solver_workspace;
 
-// Precomputations before solving the KKT system. You can think of this
-// as factoring the KKT matrix.
+/*
+ * Precomputations before solving the KKT system. You can think of this
+ * as factoring the KKT matrix.
+ */
 static void KKT_precompute(scs_float v, const scs_float *x_inv,
                            const scs_float *z, const scs_float *w, scs_int n,
                            KKT_solver_workspace *KKT_work) {
@@ -146,10 +155,11 @@ static void KKT_precompute(scs_float v, const scs_float *x_inv,
   scs_float *GinvC = KKT_work->GinvC;
   scs_float *g0g1 = KKT_work->g0g1;
   scs_float *R = KKT_work->R;
+  scs_int i;
 
   scs_float a = z[0] + 1 / (w[2] * w[2]) + z[1] * n / v;
   scs_float coeff = 0.0;
-  for (scs_int i = 0; i < n; i++) {
+  for (i = 0; i < n; i++) {
     temp1[i] = z[0] + (z[1] * v) * (x_inv[i] * x_inv[i]);
     temp2[i] = x_inv[i] / temp1[i];
     coeff += (x_inv[i] * x_inv[i]) / temp1[i];
@@ -157,34 +167,30 @@ static void KKT_precompute(scs_float v, const scs_float *x_inv,
   coeff = a - z[1] * z[1] * coeff;
   KKT_work->coeff = coeff;
 
-  // --------------------------------------------------------------------
-  //                      compute G \ g0
-  // --------------------------------------------------------------------
+  /* compute G \ g0 */
   GinvC[0] = g0g1[0] / z[0];
   GinvC[1] = (g0g1[1] + z[1] * SCS(dot)(g0g1 + 2, temp2, n)) / coeff;
-  for (scs_int i = 2; i < n + 2; i++) {
+  for (i = 2; i < n + 2; i++) {
     GinvC[i] = (g0g1[i] + (z[1] * GinvC[1]) * x_inv[i - 2]) / temp1[i - 2];
   }
   GinvC[n + 2] = -g0g1[n + 2];
 
-  // --------------------------------------------------------------------
-  //                      compute G \ g1
-  // --------------------------------------------------------------------
+  /* compute G \ g1 */
   GinvC[n + 3] = g0g1[n + 3] / z[0];
   GinvC[n + 4] =
       (g0g1[n + 4] + z[1] * SCS(dot)(g0g1 + n + 5, temp2, n)) / coeff;
-  for (scs_int i = n + 5; i < 2 * n + 5; i++) {
+  for (i = n + 5; i < 2 * n + 5; i++) {
     GinvC[i] =
         (g0g1[i] + (z[1] * GinvC[n + 4]) * x_inv[i - n - 5]) / temp1[i - n - 5];
   }
   GinvC[2 * n + 5] = -g0g1[2 * n + 5];
 
-  // compute G \ ([0, 0, ..., 0, 1])
+  /* compute G \ ([0, 0, ..., 0, 1]) */
   GinvC[3 * n + 8] = -1.0;
 
-  // ------------------------------------------------------------------------
-  //  compute R = I + C.T @ GinvC. This matrix is always reverse triangular.
-  // ------------------------------------------------------------------------
+  /*
+   * compute R = I + C.T @ GinvC. This matrix is always reverse triangular.
+   */
   R[0] = 1 + SCS(dot)(g0g1, GinvC, u_dim);
   R[3] = SCS(dot)(g0g1, GinvC + u_dim, u_dim);
   R[6] = SCS(dot)(g0g1, GinvC + 2 * u_dim, u_dim);
@@ -215,38 +221,39 @@ static void KKT_solve(const scs_float *z, const scs_float *w,
   scs_float *bnew = KKT_work->bnew;
   scs_float *g0g1 = KKT_work->g0g1;
   scs_float *CCTdu = KKT_work->CCTdu;
+  scs_float scale;
+
+  const scs_int num_ref = 3;
+  scs_int i;
+  scs_int ii;
 
-  // -------------------------------------------------------------------------
-  //                      prepare RHS
-  // -------------------------------------------------------------------------
+  /* prepare RHS */
   memcpy(rhs_reduced, rhs1, (n + 6) * sizeof(*rhs1));
   rhs_reduced[u_dim] -= w[0] * (rhs2[0] / lmbda[0]);
   rhs_reduced[u_dim + 1] -= w[1] * (rhs2[1] / lmbda[1]);
   rhs_reduced[u_dim + 2] -= w[2] * (rhs2[2] / lmbda[2]);
   memcpy(bnew, rhs_reduced, u_dim * sizeof(*rhs_reduced));
-  scs_float scale = rhs_reduced[n + 3] / w[0];
+  scale = rhs_reduced[n + 3] / w[0];
   SCS(add_scaled_array)(bnew, g0g1, u_dim, scale);
   scale = rhs_reduced[n + 4] / w[1];
   SCS(add_scaled_array)(bnew, g0g1 + u_dim, u_dim, scale);
   bnew[1] -= (rhs_reduced[n + 5] / (w[2] * w[2]));
 
-  // -------------------------------------------------------------------------
-  //                 solve system and apply iterative refinement
-  // -------------------------------------------------------------------------
+  /* solve system and apply iterative refinement */
   memcpy(residual, bnew, u_dim * sizeof(*bnew));
   memset(du1, 0, u1_dim * sizeof(*du1));
   *dr = 0;
-  const scs_int num_ref = 3;
-  for (scs_int i = 0; i < num_ref; ++i) {
-    // --------------------------------
-    // solve (G + C @ C.T) d = residual
-    // --------------------------------
+  for (i = 0; i < num_ref; ++i) {
+    char trans;
+    scs_float *Gdu;
+
+    /* solve (G + C @ C.T) d = residual */
     GinvRes[0] = residual[0] / z[0];
     GinvRes[1] =
         (residual[1] + z[1] * SCS(dot)(residual + 2, temp2, n)) / coeff;
-    for (scs_int i = 2; i < n + 2; ++i) {
-      GinvRes[i] =
-          (residual[i] + (z[1] * GinvRes[1]) * x_inv[i - 2]) / temp1[i - 2];
+    for (ii = 2; ii < n + 2; ++ii) {
+      GinvRes[ii] =
+          (residual[ii] + (z[1] * GinvRes[1]) * x_inv[ii - 2]) / temp1[ii - 2];
     }
 
     GinvRes[n + 2] = -residual[n + 2];
@@ -259,42 +266,42 @@ static void KKT_solve(const scs_float *z, const scs_float *w,
         (CTGinvRes[0] - R[0] * RinvCTGinvRes[0] - R[3] * RinvCTGinvRes[1]) /
         R[6];
 
-    // --------------------------------------------------------------------
-    //  Here we want to apply the correction d: du = du + d, where
-    //  d = GinvRes - GinvC @ RinvCTGinvRes. Note that we expect the
-    //  correction d to be very small, so we *must* compute d first and
-    //  then add it to du, instead of computing it as
-    //  du = du + GinvRes, du = du - GinvC @ RinvCTGinvRes.
-    //  In other words, the following code will result in bugs due to
-    //  numerics:
-    //  daxpy_(&u_dim, &d_one, GinvRes, &bi_one, du, &bi_one);
-    //  char trans = 'N';
-    //  dgemv_(&trans, &u_dim, &i_three, &d_minus_one, GinvC, &u_dim,
-    //         RinvCTGinvRes, &bi_one, &d_one, du, &bi_one);
-    // --------------------------------------------------------------------
-
-    char trans = 'N';
+    /*
+     * Here we want to apply the correction d: du = du + d, where
+     * d = GinvRes - GinvC @ RinvCTGinvRes. Note that we expect the
+     * correction d to be very small, so we *must* compute d first and
+     * then add it to du, instead of computing it as
+     * du = du + GinvRes, du = du - GinvC @ RinvCTGinvRes.
+     * In other words, the following code will result in bugs due to
+     * numerics:
+     * daxpy_(&u_dim, &d_one, GinvRes, &bi_one, du, &bi_one);
+     * char trans = 'N';
+     * dgemv_(&trans, &u_dim, &i_three, &d_minus_one, GinvC, &u_dim,
+     *        RinvCTGinvRes, &bi_one, &d_one, du, &bi_one);
+     */
+
+    trans = 'N';
     BLAS(gemv)(&trans, &u_dim, &bi_three, &d_minus_one, GinvC, &u_dim,
                RinvCTGinvRes, &bi_one, &d_one, GinvRes, &bi_one);
     SCS(add_scaled_array)(du1, GinvRes, u1_dim, 1.0);
     *dr += GinvRes[n + 2];
 
-    // -----------------------------------
-    //        compute new residual
-    // -----------------------------------
-    scs_float *Gdu = GinvRes;
+    /* compute new residual */
+    Gdu = GinvRes;
     if (i != num_ref - 1) {
+      scs_float coeff0;
+      scs_float coeff1;
       Gdu[0] = z[0] * du1[0];
       Gdu[1] = ((z[0] + 1 / (w[2] * w[2])) * du1[1] +
                 z[1] * (n / v * du1[1] - SCS(dot)(x_inv, du1 + 2, n)));
-      for (scs_int ii = 2; ii < n + 2; ++ii) {
+      for (ii = 2; ii < n + 2; ++ii) {
         Gdu[ii] = (z[0] * du1[ii] +
                    z[1] * (-du1[1] * x_inv[ii - 2] +
                            v * du1[ii] * x_inv[ii - 2] * x_inv[ii - 2]));
       }
       Gdu[n + 2] = -(*dr);
-      scs_float coeff0 = SCS(dot)(g0g1, du1, u1_dim) + g0g1[n + 2] * (*dr);
-      scs_float coeff1 =
+      coeff0 = SCS(dot)(g0g1, du1, u1_dim) + g0g1[n + 2] * (*dr);
+      coeff1 =
           SCS(dot)(g0g1 + u_dim, du1, u1_dim) + g0g1[2 * n + 5] * (*dr);
       memcpy(CCTdu, g0g1, u_dim * sizeof(*g0g1));
       SCS(scale_array)(CCTdu, coeff0, u_dim);
@@ -302,22 +309,22 @@ static void KKT_solve(const scs_float *z, const scs_float *w,
       CCTdu[n + 2] += (*dr);
       memcpy(residual, bnew, u_dim * sizeof(*bnew));
 
-      // important to compute the residual as residual = bnew - (Gdu +
-      // CCTdu) and not as residual = (bnew - Gdu) - CCTdu
+      /*
+       * important to compute the residual as residual = bnew - (Gdu +
+       * CCTdu) and not as residual = (bnew - Gdu) - CCTdu
+       */
       SCS(add_scaled_array)(Gdu, CCTdu, u_dim, 1.0);
       SCS(add_scaled_array)(residual, Gdu, u_dim, -1.0);
     }
   }
 
-  // -------------------------------------------------------------------------
-  //                 recover substituted variables
-  // -------------------------------------------------------------------------
+  /* recover substituted variables */
   memcpy(dz, rhs_reduced + u_dim, 3 * sizeof(*rhs_reduced));
   dz[0] -= w[0] * (SCS(dot)(g0g1, du1, u1_dim) + g0g1[n + 2] * (*dr));
   dz[1] -=
       w[1] * (SCS(dot)(g0g1 + u_dim, du1, u1_dim) + g0g1[2 * n + 5] * (*dr));
   dz[2] += du1[1];
-  for (scs_int ii = 0; ii < 3; ++ii) {
+  for (ii = 0; ii < 3; ++ii) {
     dz[ii] = -dz[ii] / (w[ii] * w[ii]);
     ds[ii] = w[ii] * (rhs2[ii] / lmbda[ii] - w[ii] * dz[ii]);
   }
@@ -334,11 +341,54 @@ scs_int log_cone_IPM(scs_float t0, scs_float v0, scs_float *x0, scs_float *u1,
   scs_int m = 3;
   scs_int u_dim = n + 3;
   scs_int u1_dim = n + 2;
+  scs_int i;
 
-  // -----------------------------------------------------------------
-  //                    scale (t0, v0, x0)
-  // -----------------------------------------------------------------
+  /* scale (t0, v0, x0) */
   scs_float scale1 = SCS(norm_inf)(x0, n);
+
+  scs_float *x_inv;
+  scs_float *z;
+  scs_float *s;
+  scs_float *f_u;
+  scs_float *grad_f0;
+  scs_float *grad_f1;
+  scs_float *rx;
+  scs_float *rznl;
+  scs_float *w;
+  scs_float *lmbda;
+  scs_float *du1;
+  scs_float *dz;
+  scs_float *ds;
+  scs_float *u1_new;
+  scs_float *z_new;
+  scs_float *s_new;
+  scs_float *x_inv_new;
+  scs_float *f_u_new;
+  scs_float *grad_f0_new;
+  scs_float *grad_f1_new;
+  scs_float *rx_new;
+  scs_float *rznl_new;
+  scs_float *u1_0;
+  scs_float *du1_0;
+  scs_float *z0;
+  scs_float *dz0;
+  scs_float *s0;
+  scs_float *ds0;
+
+  scs_float r;
+  scs_float dr;
+  scs_float rnew;
+  scs_float r0;
+  scs_float dr0;
+
+  KKT_solver_workspace KKT_work;
+
+  scs_int relaxed_iters;
+  size_t iter;
+  scs_float theta1, theta2, theta3;
+  scs_float pres0, dres0;
+  scs_float phi0, dphi0, step_size0;
+
   scale1 = MAX(t0, scale1);
   scale1 = MAX(v0, scale1);
   scale1 = 1 / scale1;
@@ -346,45 +396,42 @@ scs_int log_cone_IPM(scs_float t0, scs_float v0, scs_float *x0, scs_float *u1,
   v0 = v0 * scale1;
   SCS(scale_array)(x0, scale1, n);
 
-  // ----------------------------------------------------------------------
-  //                       Parse workspace
-  // ----------------------------------------------------------------------
-  scs_float *x_inv = workspace;
-  scs_float *z = workspace + n;
-  scs_float *s = z + m;
-  scs_float *f_u = s + m;
-  scs_float *grad_f0 = f_u + m;
-  scs_float *grad_f1 = grad_f0 + u_dim;
-  scs_float *rx = grad_f1 + u_dim;
-  scs_float *rznl = rx + u_dim;
-  scs_float *w = rznl + m;
-  scs_float *lmbda = w + m;
-  scs_float *du1 = lmbda + m;
-  scs_float *dz = du1 + u1_dim;
-  scs_float *ds = dz + m;
-
-  // for evaluating the new residuals in the line search
-  scs_float *u1_new = ds + m;
-  scs_float *z_new = u1_new + u1_dim;
-  scs_float *s_new = z_new + m;
-  scs_float *x_inv_new = s_new + m;
-  scs_float *f_u_new = x_inv_new + n;
-  scs_float *grad_f0_new = f_u_new + m;
-  scs_float *grad_f1_new = grad_f0_new + u_dim;
-  scs_float *rx_new = grad_f1_new + u_dim;
-  scs_float *rznl_new = rx_new + u_dim;
-
-  // for storing the state for the line search
-  scs_float *u1_0 = rznl_new + m;
-  scs_float *du1_0 = u1_0 + u1_dim;
-  scs_float *z0 = du1_0 + u1_dim;
-  scs_float *dz0 = z0 + m;
-  scs_float *s0 = dz0 + m;
-  scs_float *ds0 = s0 + m;
-  scs_float r0 = 0.0;
-  scs_float dr0 = 0.0;
+  /* Parse workspace */
+  x_inv = workspace;
+  z = workspace + n;
+  s = z + m;
+  f_u = s + m;
+  grad_f0 = f_u + m;
+  grad_f1 = grad_f0 + u_dim;
+  rx = grad_f1 + u_dim;
+  rznl = rx + u_dim;
+  w = rznl + m;
+  lmbda = w + m;
+  du1 = lmbda + m;
+  dz = du1 + u1_dim;
+  ds = dz + m;
+
+  /* for evaluating the new residuals in the line search */
+  u1_new = ds + m;
+  z_new = u1_new + u1_dim;
+  s_new = z_new + m;
+  x_inv_new = s_new + m;
+  f_u_new = x_inv_new + n;
+  grad_f0_new = f_u_new + m;
+  grad_f1_new = grad_f0_new + u_dim;
+  rx_new = grad_f1_new + u_dim;
+  rznl_new = rx_new + u_dim;
+
+  /* for storing the state for the line search */
+  u1_0 = rznl_new + m;
+  du1_0 = u1_0 + u1_dim;
+  z0 = du1_0 + u1_dim;
+  dz0 = z0 + m;
+  s0 = dz0 + m;
+  ds0 = s0 + m;
+  r0 = 0.0;
+  dr0 = 0.0;
 
-  KKT_solver_workspace KKT_work;
   KKT_work.g0g1 = grad_f0;
   KKT_work.temp1 = ds0 + m;
   KKT_work.temp2 = KKT_work.temp1 + u_dim;
@@ -398,29 +445,28 @@ scs_int log_cone_IPM(scs_float t0, scs_float v0, scs_float *x0, scs_float *u1,
   KKT_work.bnew = KKT_work.rhs_reduced + u_dim + 3;
   KKT_work.CCTdu = KKT_work.bnew + u_dim;
 
-  // ---------------------------------------------------------------------
-  // initialize primal variable u1 = [t, v, x], epigraph variable r and
-  // primal slack variable s and Lagrange multipliers z
-  // ---------------------------------------------------------------------
-  for (scs_int i = 0; i < n + 2; ++i) {
+  /*
+   * initialize primal variable u1 = [t, v, x], epigraph variable r and
+   * primal slack variable s and Lagrange multipliers z
+   */
+  for (i = 0; i < n + 2; ++i) {
     u1[i] = 1.0;
   }
 
-  scs_float r = 0.0;
-  scs_float dr = 0.0;
-  scs_float rnew = 0.0;
+  r = 0.0;
+  dr = 0.0;
+  rnew = 0.0;
 
-  for (scs_int i = 0; i < m; ++i) {
+  for (i = 0; i < m; ++i) {
     z[i] = 1.0;
     s[i] = 1.0;
   }
 
-  scs_int relaxed_iters = 0;
-  size_t iter = 0;
-  scs_float theta1, theta2, theta3;
-  scs_float pres0, dres0;
-  scs_float phi0 = 0.0, dphi0 = 0.0, step_size0 = 0.0;
-  // scs_int small_consecutive_steps_counter = 0;
+  relaxed_iters = 0;
+  iter = 0;
+  phi0 = 0.0;
+  dphi0 = 0.0;
+  step_size0 = 0.0;
 
 #ifdef SPECTRAL_DEBUG
   printf("%-3s%-15s%-15s%-15s%-10s%-10s\n", "", "gap", "pres", "dres", "sig",
@@ -430,18 +476,27 @@ scs_int log_cone_IPM(scs_float t0, scs_float v0, scs_float *x0, scs_float *u1,
   for (iter = 0; iter < MAX_ITER_IPM; ++iter) {
     scs_float gap = z[0] * s[0] + z[1] * s[1] + z[2] * s[2];
     scs_float mu = gap / m;
-
-    // --------------------------------------------------------
-    //                   evaluate oracle
-    // --------------------------------------------------------
-    for (scs_int i = 0; i < n; i++) {
+    scs_float dres;
+    scs_float pres;
+    scs_float norm_rx;
+    scs_float norm_rznl;
+    scs_float relgap;
+    scs_float scale2;
+    scs_float rhs2_aff[3];
+    scs_float *rhs1_aff;
+    scs_float sigma;
+    scs_float phi;
+    scs_float dphi;
+    scs_float step_size;
+    scs_int j;
+
+    /* evaluate oracle */
+    for (i = 0; i < n; i++) {
       x_inv[i] = 1 / u1[i + 2];
     }
     f_oracle(u1, r, t0, v0, x0, x_inv, n, f_u, grad_f0, grad_f1);
 
-    // --------------------------------------------------------
-    //    compute residuals and check termination criteria
-    // --------------------------------------------------------
+    /* compute residuals and check termination criteria */
     memcpy(rx, grad_f0, u_dim * sizeof(*grad_f0));
     SCS(scale_array)(rx, z[0], u_dim);
     SCS(add_scaled_array)(rx, grad_f1, u_dim, z[1]);
@@ -451,11 +506,11 @@ scs_int log_cone_IPM(scs_float t0, scs_float v0, scs_float *x0, scs_float *u1,
     rznl[1] = f_u[1] + s[1];
     rznl[2] = f_u[2] + s[2];
 
-    scs_float dres = SCS(norm_2)(rx, u_dim);
-    scs_float pres =
+    dres = SCS(norm_2)(rx, u_dim);
+    pres =
         sqrt(rznl[0] * rznl[0] + rznl[1] * rznl[1] + rznl[2] * rznl[2]);
-    scs_float norm_rx = dres;
-    scs_float norm_rznl = pres;
+    norm_rx = dres;
+    norm_rznl = pres;
 
     if (iter == 0) {
       pres0 = MAX(pres, 1.0);
@@ -467,7 +522,7 @@ scs_int log_cone_IPM(scs_float t0, scs_float v0, scs_float *x0, scs_float *u1,
 
     pres = pres / pres0;
     dres = dres / dres0;
-    scs_float relgap = gap / MAX(r, 1.0);
+    relgap = gap / MAX(r, 1.0);
 
     if (dres < FEASTOL_IPM && pres < FEASTOL_IPM &&
         (gap < ABSTOL_IPM || relgap <= RELTOL_IPM)) {
@@ -478,45 +533,44 @@ scs_int log_cone_IPM(scs_float t0, scs_float v0, scs_float *x0, scs_float *u1,
       break;
     }
 
-    // ----------------------------------------------------
-    //      compute scaling matrix and scaling point
-    // ----------------------------------------------------
-    for (scs_int i = 0; i < m; i++) {
+    /* compute scaling matrix and scaling point */
+    for (i = 0; i < m; i++) {
       w[i] = sqrt(s[i] / z[i]);
       lmbda[i] = sqrt(s[i] * z[i]);
     }
 
-    // -----------------------------------------------------------------
-    //      precomputations for KKT system
-    // -----------------------------------------------------------------
-    scs_float scale2 = 1 / w[0];
+    /* precomputations for KKT system */
+    scale2 = 1 / w[0];
     SCS(scale_array)(grad_f0, scale2, u_dim);
     scale2 = 1 / w[1];
     SCS(scale_array)(grad_f1, scale2, u_dim);
     KKT_precompute(u1[1], x_inv, z, w, n, &KKT_work);
 
-    scs_float rhs2_aff[] = {-lmbda[0] * lmbda[0], -lmbda[1] * lmbda[1],
-                            -lmbda[2] * lmbda[2]};
+    rhs2_aff[0] = -lmbda[0] * lmbda[0];
+    rhs2_aff[1] = -lmbda[1] * lmbda[1];
+    rhs2_aff[2] = -lmbda[2] * lmbda[2];
 
-    // upper bound on loop is chosen so it also iterates over rznl
-    for (scs_int i = 0; i < u_dim + 3; ++i) {
+    /* upper bound on loop is chosen so it also iterates over rznl */
+    for (i = 0; i < u_dim + 3; ++i) {
       rx[i] = -rx[i];
     }
-    scs_float *rhs1_aff = rx;
+    rhs1_aff = rx;
 
-    scs_float sigma = 0.0;
-    scs_float phi = 0.0;
-    scs_float dphi = 0.0;
-    scs_float step_size = 0.0;
+    sigma = 0.0;
+    phi = 0.0;
+    dphi = 0.0;
+    step_size = 0.0;
     phi = theta1 * gap + theta2 * norm_rx + theta3 * norm_rznl;
     dphi = -theta1 * (1 - sigma) * gap - theta2 * norm_rx - theta3 * norm_rznl;
 
-    for (scs_int i = 0; i < 2; ++i) {
-      // ------------------------------------------------------------
-      //  For i = 0 we compute the affine-scaling direction.
-      //  For i = 1 we compute the actual search direction.
-      // ------------------------------------------------------------
-      if (i == 1 && variant == 0) {
+    for (j = 0; j < 2; ++j) {
+      bool backtrack;
+
+      /*
+       * For j = 0 we compute the affine-scaling direction.
+       * For j = 1 we compute the actual search direction.
+       */
+      if (j == 1 && variant == 0) {
         SCS(scale_array)(rhs1_aff, 1 - sigma, u_dim + 3);
         rhs2_aff[0] += (sigma * mu - ds[0] * dz[0]);
         rhs2_aff[1] += (sigma * mu - ds[1] * dz[1]);
@@ -526,16 +580,19 @@ scs_int log_cone_IPM(scs_float t0, scs_float v0, scs_float *x0, scs_float *u1,
       KKT_solve(z, w, x_inv, u1[1], lmbda, n, rhs1_aff, rhs2_aff, &KKT_work,
                 du1, &dr, dz, ds);
 
-      // --------------------------------------------------------------
-      //  For i = 0 we determine the centering parameter.
-      //  For i = 1 we do a nonmonotone line search.
-      // --------------------------------------------------------------
+      /*
+       * For j = 0 we determine the centering parameter.
+       * For j = 1 we do a nonmonotone line search.
+       */
       step_size = find_max_step_size(u1, z, s, du1, dz, ds, n);
 
-      bool backtrack = true;
+      backtrack = true;
 
       while (backtrack) {
-        // u_new = u + step * du, z_new = z + step * dz, s_new = s + step
+        scs_float gap_new;
+        scs_float phi_new;
+
+        /* u_new = u + step * du, z_new = z + step * dz, s_new = s + step */
         memcpy(u1_new, u1, u1_dim * sizeof(*u1));
         SCS(add_scaled_array)(u1_new, du1, u1_dim, step_size);
         rnew = r + step_size * dr;
@@ -544,14 +601,14 @@ scs_int log_cone_IPM(scs_float t0, scs_float v0, scs_float *x0, scs_float *u1,
         memcpy(s_new, s, 3 * sizeof(*s));
         SCS(add_scaled_array)(s_new, ds, m, step_size);
 
-        // evaluate oracle in u_new
-        for (scs_int i = 0; i < n; i++) {
+        /* evaluate oracle in u_new */
+        for (i = 0; i < n; i++) {
           x_inv_new[i] = 1 / u1_new[i + 2];
         }
         f_oracle(u1_new, rnew, t0, v0, x0, x_inv_new, n, f_u_new, grad_f0_new,
                  grad_f1_new);
 
-        // compute residuals and merit function
+        /* compute residuals and merit function */
         memcpy(rx_new, grad_f0_new, u_dim * sizeof(*grad_f0_new));
         SCS(scale_array)(rx_new, z_new[0], u_dim);
         SCS(add_scaled_array)(rx_new, grad_f1_new, u_dim, z_new[1]);
@@ -560,14 +617,12 @@ scs_int log_cone_IPM(scs_float t0, scs_float v0, scs_float *x0, scs_float *u1,
         rznl_new[0] = f_u_new[0] + s_new[0];
         rznl_new[1] = f_u_new[1] + s_new[1];
         rznl_new[2] = f_u_new[2] + s_new[2];
-        scs_float gap_new = SCS(dot)(z_new, s_new, m);
-        scs_float phi_new = theta1 * gap_new +
+        gap_new = SCS(dot)(z_new, s_new, m);
+        phi_new = theta1 * gap_new +
                             theta2 * SCS(norm_2)(rx_new, u_dim) +
                             theta3 * SCS(norm_2)(rznl_new, m);
-        // ----------------------------------------------------------
-        //   For i == 0 we determine the centering parameter
-        // ----------------------------------------------------------
-        if (i == 0) {
+        /* For j == 0 we determine the centering parameter */
+        if (j == 0) {
           if (phi_new <= (1 - ALPHA_IPM * step_size) * phi) {
             backtrack = false;
             sigma = (gap_new / gap);
@@ -578,14 +633,13 @@ scs_int log_cone_IPM(scs_float t0, scs_float v0, scs_float *x0, scs_float *u1,
             step_size *= BETA_IPM;
           }
         }
-        // ------------------------------------------------------------
-        //  For i == 1 we do a nonmonotone line search with the actual
-        //  search direction
-        // ------------------------------------------------------------
+        /*
+         * For j == 1 we do a nonmonotone line search with the actual
+         * search direction
+         */
         else {
           if (relaxed_iters == -1 || MAX_RELAXED_ITERS == 0) {
             if (phi_new <= phi + ALPHA_IPM * step_size * dphi) {
-              // relaxed_iters = 0;
               backtrack = false;
             } else {
               step_size *= BETA_IPM;
@@ -611,7 +665,6 @@ scs_int log_cone_IPM(scs_float t0, scs_float v0, scs_float *x0, scs_float *u1,
             backtrack = false;
           } else if (relaxed_iters == MAX_RELAXED_ITERS) {
             if (phi_new <= phi0 + ALPHA_IPM * step_size0 * dphi0) {
-              // relaxed_iters = 0;
               backtrack = false;
             } else {
               relaxed_iters = -1;
@@ -640,7 +693,7 @@ scs_int log_cone_IPM(scs_float t0, scs_float v0, scs_float *x0, scs_float *u1,
       }
     }
 
-    // update iterates
+    /* update iterates */
     memcpy(u1, u1_new, u1_dim * sizeof(*u1));
     r = rnew;
     memcpy(z, z_new, 3 * sizeof(*z));
@@ -651,7 +704,7 @@ scs_int log_cone_IPM(scs_float t0, scs_float v0, scs_float *x0, scs_float *u1,
 #endif
   }
 
-  // unscale solution
+  /* unscale solution */
   scale1 = 1 / scale1;
   SCS(scale_array)(x0, scale1, n);
   SCS(scale_array)(u1, scale1, u1_dim);