scs 0.5.6 → 0.6.0

data/vendor/scs/linsys/scs_matrix.c

@@ -1,21 +1,31 @@
 /* contains routines common to direct and indirect sparse solvers */
+
+/* ======================== Includes / Constants ======================== */
+
 #include "scs_matrix.h"
+#include "cones.h"
 #include "linalg.h"
 #include "linsys.h"
 #include "util.h"
 
+#include <string.h>
+
 #define MIN_NORMALIZATION_FACTOR (1e-4)
 #define MAX_NORMALIZATION_FACTOR (1e4)
 #define NUM_RUIZ_PASSES (25) /* additional passes don't help much */
 #define NUM_L2_PASSES (1)    /* do one or zero, not more since not stable */
 
+/* ======================== Matrix Copy / Free ======================== */
+
 scs_int SCS(copy_matrix)(ScsMatrix **dstp, const ScsMatrix *src) {
+  scs_int Anz;
+  ScsMatrix *A;
   if (!src) {
     *dstp = SCS_NULL;
     return 1;
   }
-  scs_int Anz = src->p[src->n];
-  ScsMatrix *A = (ScsMatrix *)scs_calloc(1, sizeof(ScsMatrix));
+  Anz = src->p[src->n];
+  A = (ScsMatrix *)scs_calloc(1, sizeof(ScsMatrix));
   if (!A) {
     return 0;
   }
@@ -28,6 +38,10 @@ scs_int SCS(copy_matrix)(ScsMatrix **dstp, const ScsMatrix *src) {
   /* A column pointer, size: n+1 */
   A->p = (scs_int *)scs_calloc(src->n + 1, sizeof(scs_int));
   if (!A->x || !A->i || !A->p) {
+    scs_free(A->x);
+    scs_free(A->i);
+    scs_free(A->p);
+    scs_free(A);
     return 0;
   }
   memcpy(A->x, src->x, sizeof(scs_float) * Anz);
@@ -37,45 +51,64 @@ scs_int SCS(copy_matrix)(ScsMatrix **dstp, const ScsMatrix *src) {
   return 1;
 }
 
+void SCS(free_scs_matrix)(ScsMatrix *A) {
+  if (A) {
+    scs_free(A->x);
+    scs_free(A->i);
+    scs_free(A->p);
+    scs_free(A);
+  }
+}
+
+/* ======================== Validation ======================== */
+
 scs_int SCS(validate_lin_sys)(const ScsMatrix *A, const ScsMatrix *P) {
-  scs_int i, j, r_max, Anz;
+  scs_int i, j, Anz, Pnz;
+  if (!A) {
+    scs_printf("A matrix missing\n");
+    return -1;
+  }
+  if (A->m <= 0 || A->n <= 0) {
+    scs_printf("A matrix dimensions must be positive\n");
+    return -1;
+  }
   if (!A->x || !A->i || !A->p) {
     scs_printf("data incompletely specified\n");
     return -1;
   }
-  /* detects some errors in A col ptrs: */
-  Anz = A->p[A->n];
-  /* Disable this check which is slowish and typically just produces noise. */
-  /*
-  if (Anz > 0) {
-    for (i = 0; i < A->n; ++i) {
-      if (A->p[i] == A->p[i + 1]) {
-        scs_printf("WARN: A->p (column pointers) not strictly increasing, "
-                   "column %li empty\n",
-                   (long)i);
-      } else if (A->p[i] > A->p[i + 1]) {
-        scs_printf("ERROR: A->p (column pointers) decreasing\n");
-        return -1;
-      }
+  if (A->p[0] != 0) {
+    scs_printf("A->p[0] must equal 0\n");
+    return -1;
+  }
+  for (j = 0; j < A->n; ++j) {
+    if (A->p[j] < 0 || A->p[j] > A->p[j + 1]) {
+      scs_printf("A->p (column pointers) must be nonnegative and "
+                 "nondecreasing\n");
+      return -1;
     }
   }
-  */
+  Anz = A->p[A->n];
   if (((scs_float)Anz / A->m > A->n) || (Anz < 0)) {
     scs_printf("Anz (nonzeros in A) = %li, outside of valid range\n",
                (long)Anz);
     return -1;
   }
-  r_max = 0;
   for (i = 0; i < Anz; ++i) {
-    if (A->i[i] > r_max) {
-      r_max = A->i[i];
+    if (A->i[i] < 0 || A->i[i] >= A->m) {
+      scs_printf("A row index %li outside valid range [0, %li]\n",
+                 (long)A->i[i], (long)A->m - 1);
+      return -1;
+    }
+    if (!isfinite(A->x[i])) {
+      scs_printf("A contains a non-finite entry\n");
+      return -1;
     }
-  }
-  if (r_max > A->m - 1) {
-    scs_printf("number of rows in A inconsistent with input dimension\n");
-    return -1;
   }
   if (P) {
+    if (!P->x || !P->i || !P->p) {
+      scs_printf("P matrix incompletely specified\n");
+      return -1;
+    }
     if (P->n != A->n) {
       scs_printf("P dimension = %li, inconsistent with n = %li\n", (long)P->n,
                  (long)A->n);
@@ -85,27 +118,114 @@ scs_int SCS(validate_lin_sys)(const ScsMatrix *A, const ScsMatrix *P) {
       scs_printf("P is not square\n");
       return -1;
     }
+    if (P->p[0] != 0) {
+      scs_printf("P->p[0] must equal 0\n");
+      return -1;
+    }
+    for (j = 0; j < P->n; ++j) {
+      if (P->p[j] < 0 || P->p[j] > P->p[j + 1]) {
+        scs_printf("P->p (column pointers) must be nonnegative and "
+                   "nondecreasing\n");
+        return -1;
+      }
+    }
+    Pnz = P->p[P->n];
+    if (((scs_float)Pnz / P->m > P->n) || (Pnz < 0)) {
+      scs_printf("Pnz (nonzeros in P) = %li, outside of valid range\n",
+                 (long)Pnz);
+      return -1;
+    }
     for (j = 0; j < P->n; j++) { /* cols */
       for (i = P->p[j]; i < P->p[j + 1]; i++) {
+        if (P->i[i] < 0 || P->i[i] >= P->n) {
+          scs_printf("P row index %li outside valid range [0, %li]\n",
+                     (long)P->i[i], (long)P->n - 1);
+          return -1;
+        }
         if (P->i[i] > j) { /* if row > */
           scs_printf("P is not upper triangular\n");
           return -1;
         }
+        if (!isfinite(P->x[i])) {
+          scs_printf("P contains a non-finite entry\n");
+          return -1;
+        }
       }
     }
   }
   return 0;
 }
 
-void SCS(free_scs_matrix)(ScsMatrix *A) {
-  if (A) {
-    scs_free(A->x);
-    scs_free(A->i);
-    scs_free(A->p);
-    scs_free(A);
+/* ======================== Matrix-Vector Products ======================== */
+
+void SCS(accum_by_atrans)(const ScsMatrix *A, const scs_float *x,
+                          scs_float *y) {
+  /* y += A'*x
+     A in column compressed format
+     parallelizes over columns (rows of A')
+   */
+  scs_int p, j;
+  scs_int c1, c2;
+  scs_float yj;
+  scs_int n = A->n;
+  scs_int *Ap = A->p;
+  scs_int *Ai = A->i;
+  scs_float *Ax = A->x;
+#ifdef _OPENMP
+#pragma omp parallel for private(p, c1, c2, yj)
+#endif
+  for (j = 0; j < n; j++) {
+    yj = y[j];
+    c1 = Ap[j];
+    c2 = Ap[j + 1];
+    for (p = c1; p < c2; p++) {
+      yj += Ax[p] * x[Ai[p]];
+    }
+    y[j] = yj;
+  }
+}
+
+void SCS(accum_by_a)(const ScsMatrix *A, const scs_float *x, scs_float *y) {
+  /*y += A*x
+    A in column compressed format
+    */
+  scs_int p, j, i;
+  scs_int n = A->n;
+  scs_int *Ap = A->p;
+  scs_int *Ai = A->i;
+  scs_float *Ax = A->x;
+  for (j = 0; j < n; j++) { /* col */
+    for (p = Ap[j]; p < Ap[j + 1]; p++) {
+      i = Ai[p]; /* row */
+      y[i] += Ax[p] * x[j];
+    }
+  }
+}
+
+/* Since P is upper triangular need to be clever here */
+void SCS(accum_by_p)(const ScsMatrix *P, const scs_float *x, scs_float *y) {
+  /* returns y += P x where P is stored upper triangular (CSC).
+   * Single pass: each stored entry (i,j) contributes to both y[i] (upper)
+   * and y[j] (symmetric lower), halving NNZ traversals vs two-pass approach. */
+  scs_int p, j;
+  scs_int n = P->n;
+  scs_int *Pp = P->p;
+  scs_int *Pi = P->i;
+  scs_float *Px = P->x;
+  for (j = 0; j < n; j++) {
+    for (p = Pp[j]; p < Pp[j + 1]; p++) {
+      scs_int i = Pi[p];
+      scs_float val = Px[p];
+      y[i] += val * x[j]; /* upper triangle + diagonal */
+      if (i != j) {
+        y[j] += val * x[i]; /* symmetric lower triangle */
+      }
+    }
   }
 }
 
+/* ======================== Normalization Internals ======================== */
+
 static inline scs_float apply_limit(scs_float x) {
   /* need to bound to 1 for cols/rows of all zeros, otherwise blows up */
   x = x < MIN_NORMALIZATION_FACTOR ? 1.0 : x;
@@ -113,18 +233,27 @@ static inline scs_float apply_limit(scs_float x) {
   return x;
 }
 
-static void compute_ruiz_mats(ScsMatrix *P, ScsMatrix *A, scs_float *Dt,
-                              scs_float *Et, ScsConeWork *cone) {
+/* Equilibrates the full homogeneous-embedding operator
+ *   Q = [ 0   A'  c ]
+ *       [-A   0   b ]
+ *       [-c' -b'  0 ]
+ * with the symmetric scaling diag(E, D, st): |Q| is symmetric so row and
+ * column norms coincide, b enters the row norms, c the column norms, and
+ * the scalar st on the tau slot replaces the old one-shot clamped sigma
+ * heuristic in normalize_b_c. bt/ct are the running scaled copies of b/c
+ * maintained by the caller; *st_out receives this pass's tau scaling. */
+static void compute_ruiz_mats(ScsMatrix *P, ScsMatrix *A, const scs_float *bt,
+                              const scs_float *ct, scs_float *Dt,
+                              scs_float *Et, scs_float *st_out,
+                              ScsConeWork *cone) {
   scs_int i, j, kk;
   scs_float wrk;
-  scs_float nm_a_col;
 
   /****************************  D  ****************************/
 
-  /* initialize D */
+  /* initialize D with the tau-column contribution */
   for (i = 0; i < A->m; ++i) {
-    Dt[i] = 0.;
-    /* Dt[i] = ABS(b[i]); */
+    Dt[i] = ABS(bt[i]);
   }
 
   /* calculate row norms */
@@ -135,7 +264,7 @@ static void compute_ruiz_mats(ScsMatrix *P, ScsMatrix *A, scs_float *Dt,
   }
 
   /* accumulate D across each cone  */
-  SCS(enforce_cone_boundaries)(cone, Dt, &SCS(norm_inf));
+  SCS(enforce_cone_boundaries)(cone, Dt, &SCS(norm_inf), 0);
 
   /* invert temporary vec to form D */
   for (i = 0; i < A->m; ++i) {
@@ -145,10 +274,9 @@ static void compute_ruiz_mats(ScsMatrix *P, ScsMatrix *A, scs_float *Dt,
 
   /****************************  E  ****************************/
 
-  /* initialize E */
+  /* initialize E with the tau-row contribution */
   for (i = 0; i < A->n; ++i) {
-    Et[i] = 0.;
-    /* Et[i] = ABS(c[i]); */
+    Et[i] = ABS(ct[i]);
   }
 
   /* TODO: test not using P to determine scaling  */
@@ -169,40 +297,76 @@ static void compute_ruiz_mats(ScsMatrix *P, ScsMatrix *A, scs_float *Dt,
     }
   }
 
-  /* calculate col norms, E */
+  /* calculate col norms, E — inline the norm_inf to avoid n BLAS call
+   * overheads (Fortran ABI, pointer args, 1-based return) for short cols. */
   for (i = 0; i < A->n; ++i) {
-    nm_a_col = SCS(norm_inf)(&(A->x[A->p[i]]), A->p[i + 1] - A->p[i]);
+    scs_float nm_a_col = 0.0, tmp;
+    for (j = A->p[i]; j < A->p[i + 1]; ++j) {
+      tmp = ABS(A->x[j]);
+      if (tmp > nm_a_col) nm_a_col = tmp;
+    }
     Et[i] = MAX(Et[i], nm_a_col);
     Et[i] = SQRTF(apply_limit(Et[i]));
     Et[i] = SAFEDIV_POS(1.0, Et[i]);
   }
+
+  /**************************  tau  ****************************/
+  wrk = MAX(SCS(norm_inf)(bt, A->m), SCS(norm_inf)(ct, A->n));
+  *st_out = SAFEDIV_POS(1.0, SQRTF(apply_limit(wrk)));
 }
 
-static void compute_l2_mats(ScsMatrix *P, ScsMatrix *A, scs_float *Dt,
-                            scs_float *Et, ScsConeWork *cone) {
+/* The l2 pass normalizes by RMS (root-mean-square over stored entries)
+ * rather than the raw l2 norm. The raw l2 norm of a row/column grows like
+ * sqrt(nnz) times its typical entry magnitude, so dividing by it crushes
+ * dense or flat rows/columns by an extra nnz^(1/4) factor relative to
+ * sparse ones -- a density artifact, not a magnitude signal (the Ruiz
+ * linf passes are density-blind). RMS measures typical entry magnitude
+ * while keeping the l2 pass's averaging robustness. Under the stacked
+ * equilibration the b/c entries count toward their row/column averages,
+ * and the tau norms average over their own lengths.
+ */
+
+static void compute_l2_mats(ScsMatrix *P, ScsMatrix *A, const scs_float *bt,
+                            const scs_float *ct, scs_float *Dt, scs_float *Et,
+                            scs_float *st_out, ScsConeWork *cone) {
   scs_int i, j, kk;
+  scs_int rms = 1;
   scs_float wrk;
+  scs_float *rcnt = SCS_NULL, *ecnt = SCS_NULL;
+  rcnt = (scs_float *)scs_calloc(A->m, sizeof(scs_float));
+  ecnt = (scs_float *)scs_calloc(A->n, sizeof(scs_float));
+  if (!rcnt || !ecnt) {
+    scs_free(rcnt);
+    scs_free(ecnt);
+    rcnt = ecnt = SCS_NULL;
+    rms = 0; /* fall back to plain l2 on alloc failure */
+  }
 
   /****************************  D  ****************************/
 
-  /* initialize D */
+  /* initialize D with the tau-column contribution */
   for (i = 0; i < A->m; ++i) {
-    Dt[i] = 0.;
-    /* Dt[i] = b[i] * b[i]; */
+    Dt[i] = bt[i] * bt[i];
   }
 
   /* calculate row norms */
   for (i = 0; i < A->n; ++i) {
     for (j = A->p[i]; j < A->p[i + 1]; ++j) {
       Dt[A->i[j]] += A->x[j] * A->x[j];
+      if (rms) {
+        rcnt[A->i[j]] += 1.;
+      }
     }
   }
   for (i = 0; i < A->m; ++i) {
-    Dt[i] = SQRTF(Dt[i]); /* l2 norm of rows */
+    if (rms) {
+      Dt[i] /= (rcnt[i] + 1.); /* +1 for the bt (tau-column) entry */
+    }
+    Dt[i] = SQRTF(Dt[i]); /* l2 (or rms) norm of rows */
   }
 
   /* accumulate D across each cone  */
-  SCS(enforce_cone_boundaries)(cone, Dt, &SCS(mean));
+  SCS(enforce_cone_boundaries)(cone, Dt, &SCS(mean), 0);
 
   for (i = 0; i < A->m; ++i) {
     Dt[i] = SQRTF(apply_limit(Dt[i]));
@@ -211,10 +375,9 @@ static void compute_l2_mats(ScsMatrix *P, ScsMatrix *A, scs_float *Dt,
 
   /****************************  E  ****************************/
 
-  /* initialize E */
+  /* initialize E with the tau-row contribution */
   for (i = 0; i < A->n; ++i) {
-    Et[i] = 0.;
-    /* Et[i] = c[i] * c[i]; */
+    Et[i] = ct[i] * ct[i];
   }
 
   /* TODO: test not using P to determine scaling  */
@@ -228,8 +391,14 @@ static void compute_l2_mats(ScsMatrix *P, ScsMatrix *A, scs_float *Dt,
         i = P->i[kk]; /* row */
         wrk = P->x[kk] * P->x[kk];
         Et[j] += wrk;
+        if (rms) {
+          ecnt[j] += 1.;
+        }
         if (i != j) {
           Et[i] += wrk;
+          if (rms) {
+            ecnt[i] += 1.;
+          }
         }
       }
     }
@@ -238,37 +407,56 @@ static void compute_l2_mats(ScsMatrix *P, ScsMatrix *A, scs_float *Dt,
   /* calculate col norms, E */
   for (i = 0; i < A->n; ++i) {
     Et[i] += SCS(norm_sq)(&(A->x[A->p[i]]), A->p[i + 1] - A->p[i]);
+    if (rms) {
+      Et[i] /= (ecnt[i] + (scs_float)(A->p[i + 1] - A->p[i]) + 1.);
+    }
     Et[i] = SQRTF(apply_limit(SQRTF(Et[i])));
     Et[i] = SAFEDIV_POS(1.0, Et[i]);
   }
+
+  /**************************  tau  ****************************/
+  if (rms) {
+    wrk = MAX(SCS(norm_2)(bt, A->m) / SQRTF((scs_float)A->m),
+              SCS(norm_2)(ct, A->n) / SQRTF((scs_float)A->n));
+  } else {
+    wrk = MAX(SCS(norm_2)(bt, A->m), SCS(norm_2)(ct, A->n));
+  }
+  *st_out = SAFEDIV_POS(1.0, SQRTF(apply_limit(wrk)));
+  scs_free(rcnt);
+  scs_free(ecnt);
 }
 
-static void rescale(ScsMatrix *P, ScsMatrix *A, scs_float *Dt, scs_float *Et,
+static void rescale(ScsMatrix *P, ScsMatrix *A, scs_float *bt, scs_float *ct,
+                    scs_float st, scs_float *Dt, scs_float *Et,
                     ScsScaling *scal, ScsConeWork *cone) {
   scs_int i, j;
-  /* scale the rows of A with D */
+  /* Fuse row and col scaling of A: A[i,j] *= Dt[i] * Et[j].
+   * Single NNZ pass replaces two separate passes. */
   for (i = 0; i < A->n; ++i) {
+    scs_float ei = Et[i];
     for (j = A->p[i]; j < A->p[i + 1]; ++j) {
-      A->x[j] *= Dt[A->i[j]];
+      A->x[j] *= Dt[A->i[j]] * ei;
     }
   }
 
-  /* scale the cols of A with E */
-  for (i = 0; i < A->n; ++i) {
-    SCS(scale_array)(&(A->x[A->p[i]]), Et[i], A->p[i + 1] - A->p[i]);
-  }
-
   if (P) {
-    /* scale the rows of P with E */
+    /* Fuse row and col scaling of P: P[i,j] *= Et[i] * Et[j]. */
     for (i = 0; i < P->n; ++i) {
+      scs_float ei = Et[i];
       for (j = P->p[i]; j < P->p[i + 1]; ++j) {
-        P->x[j] *= Et[P->i[j]];
+        P->x[j] *= Et[P->i[j]] * ei;
       }
     }
-    /* scale the cols of P with E */
-    for (i = 0; i < P->n; ++i) {
-      SCS(scale_array)(&(P->x[P->p[i]]), Et[i], P->p[i + 1] - P->p[i]);
-    }
+  }
+
+  /* Scale the running b/c copies by their row/col factors and the tau
+   * scalar (the b entries live at (row i, col tau), c at (row tau, col j)
+   * of the stacked operator). */
+  for (i = 0; i < A->m; ++i) {
+    bt[i] *= Dt[i] * st;
+  }
+  for (i = 0; i < A->n; ++i) {
+    ct[i] *= Et[i] * st;
   }
 
   /* Accumulate scaling */
@@ -278,6 +466,7 @@ static void rescale(ScsMatrix *P, ScsMatrix *A, scs_float *Dt, scs_float *Et,
   for (i = 0; i < A->n; ++i) {
     scal->E[i] *= Et[i];
   }
+  scal->tau_scale *= st;
 
   /* no need to scale P since later primal_scale = dual_scale */
   /*
@@ -288,6 +477,8 @@ static void rescale(ScsMatrix *P, ScsMatrix *A, scs_float *Dt, scs_float *Et,
   */
 }
 
+/* ======================== Normalization Public API ======================== */
+
 /* Will rescale as P -> EPE, A -> DAE in-place.
  * Essentially trying to rescale this matrix:
  *
@@ -310,13 +501,37 @@ static void rescale(ScsMatrix *P, ScsMatrix *A, scs_float *Dt, scs_float *Et,
  * The main complication is that D has to respect cone boundaries.
  *
  */
-ScsScaling *SCS(normalize_a_p)(ScsMatrix *P, ScsMatrix *A, ScsConeWork *cone) {
+ScsScaling *SCS(normalize_a_p)(ScsMatrix *P, ScsMatrix *A, const scs_float *b,
+                               const scs_float *c, ScsConeWork *cone) {
   scs_int i;
+  scs_float st;
   ScsScaling *scal = (ScsScaling *)scs_calloc(1, sizeof(ScsScaling));
   scs_float *Dt = (scs_float *)scs_calloc(A->m, sizeof(scs_float));
   scs_float *Et = (scs_float *)scs_calloc(A->n, sizeof(scs_float));
+  /* running scaled copies of b, c (originals must not be modified here;
+   * their actual scaling happens per-solve in normalize_b_c) */
+  scs_float *bt = (scs_float *)scs_malloc(A->m * sizeof(scs_float));
+  scs_float *ct = (scs_float *)scs_malloc(A->n * sizeof(scs_float));
+  if (!scal || !Dt || !Et || !bt || !ct) {
+    scs_free(scal);
+    scs_free(Dt);
+    scs_free(Et);
+    scs_free(bt);
+    scs_free(ct);
+    return SCS_NULL;
+  }
+  memcpy(bt, b, A->m * sizeof(scs_float));
+  memcpy(ct, c, A->n * sizeof(scs_float));
   scal->D = (scs_float *)scs_calloc(A->m, sizeof(scs_float));
   scal->E = (scs_float *)scs_calloc(A->n, sizeof(scs_float));
+  if (!scal->D || !scal->E) {
+    scs_free(scal->D);
+    scs_free(scal->E);
+    scs_free(scal);
+    scs_free(Dt);
+    scs_free(Et);
+    return SCS_NULL;
+  }
 
 #if VERBOSITY > 5
   SCS(timer) normalize_timer;
@@ -335,16 +550,20 @@ ScsScaling *SCS(normalize_a_p)(ScsMatrix *P, ScsMatrix *A, ScsConeWork *cone) {
   }
   scal->primal_scale = 1.;
   scal->dual_scale = 1.;
+  scal->tau_scale = 1.;
   for (i = 0; i < NUM_RUIZ_PASSES; ++i) {
-    compute_ruiz_mats(P, A, Dt, Et, cone);
-    rescale(P, A, Dt, Et, scal, cone);
+    compute_ruiz_mats(P, A, bt, ct, Dt, Et, &st, cone);
+    rescale(P, A, bt, ct, st, Dt, Et, scal, cone);
   }
   for (i = 0; i < NUM_L2_PASSES; ++i) {
-    compute_l2_mats(P, A, Dt, Et, cone);
-    rescale(P, A, Dt, Et, scal, cone);
+    compute_l2_mats(P, A, bt, ct, Dt, Et, &st, cone);
+    rescale(P, A, bt, ct, st, Dt, Et, scal, cone);
   }
+
   scs_free(Dt);
   scs_free(Et);
+  scs_free(bt);
+  scs_free(ct);
 
 #if VERBOSITY > 5
   scs_printf("finished normalizing A and P, time: %1.2es\n",
@@ -360,96 +579,3 @@ ScsScaling *SCS(normalize_a_p)(ScsMatrix *P, ScsMatrix *A, ScsConeWork *cone) {
 #endif
   return scal;
 }
-
-/*
-void SCS(un_normalize_a_p)(ScsMatrix *A, ScsMatrix *P, const ScsScaling *scal) {
-  scs_int i, j;
-  scs_float *D = scal->D;
-  scs_float *E = scal->E;
-  for (i = 0; i < A->n; ++i) {
-    SCS(scale_array)
-    (&(A->x[A->p[i]]), 1. / E[i], A->p[i + 1] - A->p[i]);
-  }
-  for (i = 0; i < A->n; ++i) {
-    for (j = A->p[i]; j < A->p[i + 1]; ++j) {
-      A->x[j] /= D[A->i[j]];
-    }
-  }
-  if (P) {
-    for (i = 0; i < P->n; ++i) {
-      SCS(scale_array)
-      (&(P->x[P->p[i]]), 1. / E[i], P->p[i + 1] - P->p[i]);
-    }
-    for (i = 0; i < P->n; ++i) {
-      for (j = P->p[i]; j < P->p[i + 1]; ++j) {
-        P->x[j] /= E[P->i[j]];
-      }
-    }
-  }
-}
-*/
-
-void SCS(accum_by_atrans)(const ScsMatrix *A, const scs_float *x,
-                          scs_float *y) {
-  /* y += A'*x
-     A in column compressed format
-     parallelizes over columns (rows of A')
-   */
-  scs_int p, j;
-  scs_int c1, c2;
-  scs_float yj;
-  scs_int n = A->n;
-  scs_int *Ap = A->p;
-  scs_int *Ai = A->i;
-  scs_float *Ax = A->x;
-#ifdef _OPENMP
-#pragma omp parallel for private(p, c1, c2, yj)
-#endif
-  for (j = 0; j < n; j++) {
-    yj = y[j];
-    c1 = Ap[j];
-    c2 = Ap[j + 1];
-    for (p = c1; p < c2; p++) {
-      yj += Ax[p] * x[Ai[p]];
-    }
-    y[j] = yj;
-  }
-}
-
-void SCS(accum_by_a)(const ScsMatrix *A, const scs_float *x, scs_float *y) {
-  /*y += A*x
-    A in column compressed format
-    */
-  scs_int p, j, i;
-  scs_int n = A->n;
-  scs_int *Ap = A->p;
-  scs_int *Ai = A->i;
-  scs_float *Ax = A->x;
-  for (j = 0; j < n; j++) { /* col */
-    for (p = Ap[j]; p < Ap[j + 1]; p++) {
-      i = Ai[p]; /* row */
-      y[i] += Ax[p] * x[j];
-    }
-  }
-}
-
-/* Since P is upper triangular need to be clever here */
-void SCS(accum_by_p)(const ScsMatrix *P, const scs_float *x, scs_float *y) {
-  /* returns y += P x */
-  scs_int p, j, i;
-  scs_int n = P->n;
-  scs_int *Pp = P->p;
-  scs_int *Pi = P->i;
-  scs_float *Px = P->x;
-  /* y += P_upper x but skip diagonal entries*/
-  for (j = 0; j < n; j++) { /* col */
-    for (p = Pp[j]; p < Pp[j + 1]; p++) {
-      i = Pi[p];    /* row */
-      if (i != j) { /* skip the diagonal */
-        y[i] += Px[p] * x[j];
-      }
-    }
-  }
-  /* y += P_lower x */
-  SCS(accum_by_atrans)(P, x, y);
-}