scs 0.3.0 → 0.4.0

data/vendor/scs/linsys/cpu/direct/private.c

@@ -18,10 +18,11 @@ void SCS(free_lin_sys_work)(ScsLinSysWork *p) {
   if (p) {
     SCS(cs_spfree)(p->L);
     SCS(cs_spfree)(p->kkt);
+    scs_free(p->diag_p);
     scs_free(p->perm);
     scs_free(p->Dinv);
     scs_free(p->bp);
-    scs_free(p->rho_y_vec_idxs);
+    scs_free(p->diag_r_idxs);
     scs_free(p->Lnz);
     scs_free(p->iwork);
     scs_free(p->etree);
@@ -32,9 +33,8 @@ void SCS(free_lin_sys_work)(ScsLinSysWork *p) {
   }
 }
 
-static csc *form_kkt(const ScsMatrix *A, const ScsMatrix *P,
-                     scs_float *rho_y_vec, scs_int *rho_y_vec_idxs,
-                     scs_float rho_x) {
+static csc *form_kkt(const ScsMatrix *A, const ScsMatrix *P, scs_float *diag_p,
+                     const scs_float *diag_r, scs_int *diag_r_idxs) {
   /* ONLY UPPER TRIANGULAR PART IS STUFFED
    * forms column compressed kkt matrix
    * assumes column compressed form A matrix
@@ -42,7 +42,7 @@ static csc *form_kkt(const ScsMatrix *A, const ScsMatrix *P,
    * forms upper triangular part of [(I + P)  A'; A -I]
    * P : n x n, A: m x n.
    */
-  scs_int i, j, k, kk;
+  scs_int h, i, j, count;
   csc *Kcsc, *K;
   scs_int n = A->n;
   scs_int m = A->m;
@@ -65,72 +65,80 @@ static csc *form_kkt(const ScsMatrix *A, const ScsMatrix *P,
     return SCS_NULL;
   }
 
-  kk = 0; /* element counter */
+  count = 0; /* element counter */
   if (P) {
-    /* I + P in top left */
-    for (j = 0; j < P->n; j++) { /* cols */
+    /* R_x + P in top left */
+    for (j = 0; j < n; j++) { /* cols */
+      diag_p[j] = 0.;
       /* empty column, add diagonal  */
       if (P->p[j] == P->p[j + 1]) {
-        K->i[kk] = j;
-        K->p[kk] = j;
-        K->x[kk] = rho_x;
-        kk++;
+        K->i[count] = j;
+        K->p[count] = j;
+        K->x[count] = diag_r[j];
+        diag_r_idxs[j] = count; /* store the indices where diag_r occurs */
+        count++;
       }
-      for (k = P->p[j]; k < P->p[j + 1]; k++) {
-        i = P->i[k]; /* row */
+      for (h = P->p[j]; h < P->p[j + 1]; h++) {
+        i = P->i[h]; /* row */
         if (i > j) { /* only upper triangular needed */
           break;
         }
-        K->i[kk] = i;
-        K->p[kk] = j;
-        K->x[kk] = P->x[k];
+        K->i[count] = i;
+        K->p[count] = j;
+        K->x[count] = P->x[h];
         if (i == j) {
           /* P has diagonal element */
-          K->x[kk] += rho_x;
+          diag_p[j] = P->x[h];
+          K->x[count] += diag_r[j];
+          diag_r_idxs[j] = count; /* store the indices where diag_r occurs */
         }
-        kk++;
+        count++;
         /* reached the end without adding diagonal, do it now */
-        if ((i < j) && (k + 1 == P->p[j + 1] || P->i[k + 1] > j)) {
-          K->i[kk] = j;
-          K->p[kk] = j;
-          K->x[kk] = rho_x;
-          kk++;
+        if ((i < j) && (h + 1 == P->p[j + 1] || P->i[h + 1] > j)) {
+          K->i[count] = j;
+          K->p[count] = j;
+          K->x[count] = diag_r[j];
+          diag_r_idxs[j] = count; /* store the indices where diag_r occurs */
+          count++;
         }
       }
     }
   } else {
-    /* rho_x * I in top left */
-    for (k = 0; k < A->n; k++) {
-      K->i[kk] = k;
-      K->p[kk] = k;
-      K->x[kk] = rho_x;
-      kk++;
+    /* R_x in top left */
+    for (j = 0; j < n; j++) {
+      diag_p[j] = 0.;
+      K->i[count] = j;
+      K->p[count] = j;
+      K->x[count] = diag_r[j];
+      diag_r_idxs[j] = count; /* store the indices where diag_r occurs */
+      count++;
     }
   }
 
   /* A^T at top right */
   for (j = 0; j < n; j++) {
-    for (k = A->p[j]; k < A->p[j + 1]; k++) {
-      K->p[kk] = A->i[k] + n;
-      K->i[kk] = j;
-      K->x[kk] = A->x[k];
-      kk++;
+    for (h = A->p[j]; h < A->p[j + 1]; h++) {
+      K->p[count] = A->i[h] + n;
+      K->i[count] = j;
+      K->x[count] = A->x[h];
+      count++;
     }
   }
 
-  /* -rho_y_vec * I at bottom right */
-  for (k = 0; k < m; k++) {
-    K->i[kk] = k + n;
-    K->p[kk] = k + n;
-    K->x[kk] = -rho_y_vec[k];
-    rho_y_vec_idxs[k] = kk; /* store the indices where rho_y_vec occurs */
-    kk++;
+  /* -R_y at bottom right */
+  for (j = 0; j < m; j++) {
+    K->i[count] = j + n;
+    K->p[count] = j + n;
+    K->x[count] = -diag_r[j + n];
+    diag_r_idxs[j + n] = count; /* store the indices where diag_r occurs */
+    count++;
   }
-  K->nz = kk;
-  idx_mapping = (scs_int *)scs_malloc(K->nz * sizeof(scs_int));
+
+  K->nz = count;
+  idx_mapping = (scs_int *)scs_calloc(K->nz, sizeof(scs_int));
   Kcsc = SCS(cs_compress)(K, idx_mapping);
-  for (i = 0; i < A->m; i++) {
-    rho_y_vec_idxs[i] = idx_mapping[rho_y_vec_idxs[i]];
+  for (i = 0; i < m + n; i++) {
+    diag_r_idxs[i] = idx_mapping[diag_r_idxs[i]];
   }
   SCS(cs_spfree)(K);
   scs_free(idx_mapping);
@@ -138,7 +146,7 @@ static csc *form_kkt(const ScsMatrix *A, const ScsMatrix *P,
 }
 
 static scs_int _ldl_init(csc *A, scs_int *P, scs_float **info) {
-  *info = (scs_float *)scs_malloc(AMD_INFO * sizeof(scs_float));
+  *info = (scs_float *)scs_calloc(AMD_INFO, sizeof(scs_float));
   return amd_order(A->n, A->p, A->i, P, (scs_float *)SCS_NULL, *info);
 }
 
@@ -146,10 +154,10 @@ static scs_int _ldl_init(csc *A, scs_int *P, scs_float **info) {
 static scs_int ldl_prepare(ScsLinSysWork *p) {
   csc *kkt = p->kkt, *L = p->L;
   scs_int n = kkt->n;
-  p->etree = (scs_int *)scs_malloc(n * sizeof(scs_int));
-  p->Lnz = (scs_int *)scs_malloc(n * sizeof(scs_int));
-  p->iwork = (scs_int *)scs_malloc(3 * n * sizeof(scs_int));
-  L->p = (scs_int *)scs_malloc((1 + n) * sizeof(scs_int));
+  p->etree = (scs_int *)scs_calloc(n, sizeof(scs_int));
+  p->Lnz = (scs_int *)scs_calloc(n, sizeof(scs_int));
+  p->iwork = (scs_int *)scs_calloc(3 * n, sizeof(scs_int));
+  L->p = (scs_int *)scs_calloc((1 + n), sizeof(scs_int));
   L->nzmax = QDLDL_etree(n, kkt->p, kkt->i, p->iwork, p->Lnz, p->etree);
   if (L->nzmax < 0) {
     scs_printf("Error in elimination tree calculation.\n");
@@ -161,12 +169,12 @@ static scs_int ldl_prepare(ScsLinSysWork *p) {
     return L->nzmax;
   }
 
-  L->x = (scs_float *)scs_malloc(L->nzmax * sizeof(scs_float));
-  L->i = (scs_int *)scs_malloc(L->nzmax * sizeof(scs_int));
-  p->Dinv = (scs_float *)scs_malloc(n * sizeof(scs_float));
-  p->D = (scs_float *)scs_malloc(n * sizeof(scs_float));
-  p->bwork = (scs_int *)scs_malloc(n * sizeof(scs_int));
-  p->fwork = (scs_float *)scs_malloc(n * sizeof(scs_float));
+  L->x = (scs_float *)scs_calloc(L->nzmax, sizeof(scs_float));
+  L->i = (scs_int *)scs_calloc(L->nzmax, sizeof(scs_int));
+  p->Dinv = (scs_float *)scs_calloc(n, sizeof(scs_float));
+  p->D = (scs_float *)scs_calloc(n, sizeof(scs_float));
+  p->bwork = (scs_int *)scs_calloc(n, sizeof(scs_int));
+  p->fwork = (scs_float *)scs_calloc(n, sizeof(scs_float));
   return L->nzmax;
 }
 
@@ -223,7 +231,7 @@ static scs_int *cs_pinv(scs_int const *p, scs_int n) {
   if (!p) {
     return SCS_NULL;
   } /* p = SCS_NULL denotes identity */
-  pinv = (scs_int *)scs_malloc(n * sizeof(scs_int)); /* allocate result */
+  pinv = (scs_int *)scs_calloc(n, sizeof(scs_int)); /* allocate result */
   if (!pinv) {
     return SCS_NULL;
   } /* out of memory */
@@ -283,10 +291,10 @@ static csc *cs_symperm(const csc *A, const scs_int *pinv, scs_int *idx_mapping,
 }
 
 static csc *permute_kkt(const ScsMatrix *A, const ScsMatrix *P,
-                        ScsLinSysWork *p, scs_float *rho_y_vec) {
+                        ScsLinSysWork *p, const scs_float *diag_r) {
   scs_float *info;
   scs_int *Pinv, amd_status, *idx_mapping, i;
-  csc *kkt_perm, *kkt = form_kkt(A, P, rho_y_vec, p->rho_y_vec_idxs, p->rho_x);
+  csc *kkt_perm, *kkt = form_kkt(A, P, p->diag_p, diag_r, p->diag_r_idxs);
   if (!kkt) {
     return SCS_NULL;
   }
@@ -300,10 +308,10 @@ static csc *permute_kkt(const ScsMatrix *A, const ScsMatrix *P,
   amd_info(info);
 #endif
   Pinv = cs_pinv(p->perm, A->n + A->m);
-  idx_mapping = (scs_int *)scs_malloc(kkt->nzmax * sizeof(scs_int));
+  idx_mapping = (scs_int *)scs_calloc(kkt->nzmax, sizeof(scs_int));
   kkt_perm = cs_symperm(kkt, Pinv, idx_mapping, 1);
-  for (i = 0; i < A->m; i++) {
-    p->rho_y_vec_idxs[i] = idx_mapping[p->rho_y_vec_idxs[i]];
+  for (i = 0; i < A->n + A->m; i++) {
+    p->diag_r_idxs[i] = idx_mapping[p->diag_r_idxs[i]];
   }
   SCS(cs_spfree)(kkt);
   scs_free(Pinv);
@@ -312,10 +320,15 @@ static csc *permute_kkt(const ScsMatrix *A, const ScsMatrix *P,
   return kkt_perm;
 }
 
-void SCS(update_lin_sys_rho_y_vec)(ScsLinSysWork *p, scs_float *rho_y_vec) {
+void SCS(update_lin_sys_diag_r)(ScsLinSysWork *p, const scs_float *diag_r) {
   scs_int i, ldl_status;
-  for (i = 0; i < p->m; ++i) {
-    p->kkt->x[p->rho_y_vec_idxs[i]] = -rho_y_vec[i];
+  for (i = 0; i < p->n; ++i) {
+    /* top left is R_x + P, bottom right is -R_y */
+    p->kkt->x[p->diag_r_idxs[i]] = p->diag_p[i] + diag_r[i];
+  }
+  for (i = p->n; i < p->n + p->m; ++i) {
+    /* top left is R_x + P, bottom right is -R_y */
+    p->kkt->x[p->diag_r_idxs[i]] = -diag_r[i];
   }
   ldl_status = ldl_factor(p, p->n);
   if (ldl_status < 0) {
@@ -327,21 +340,21 @@ void SCS(update_lin_sys_rho_y_vec)(ScsLinSysWork *p, scs_float *rho_y_vec) {
 }
 
 ScsLinSysWork *SCS(init_lin_sys_work)(const ScsMatrix *A, const ScsMatrix *P,
-                                      scs_float *rho_y_vec, scs_float rho_x) {
+                                      const scs_float *diag_r) {
   ScsLinSysWork *p = (ScsLinSysWork *)scs_calloc(1, sizeof(ScsLinSysWork));
   scs_int n_plus_m = A->n + A->m, ldl_status, ldl_prepare_status;
   p->m = A->m;
   p->n = A->n;
-  p->rho_x = rho_x;
-  p->perm = (scs_int *)scs_malloc(sizeof(scs_int) * n_plus_m);
-  p->L = (csc *)scs_malloc(sizeof(csc));
-  p->bp = (scs_float *)scs_malloc(n_plus_m * sizeof(scs_float));
-  p->rho_y_vec_idxs = (scs_int *)scs_malloc(A->m * sizeof(scs_int));
+  p->diag_p = (scs_float *)scs_calloc(A->n, sizeof(scs_float));
+  p->perm = (scs_int *)scs_calloc(sizeof(scs_int), n_plus_m);
+  p->L = (csc *)scs_calloc(1, sizeof(csc));
+  p->bp = (scs_float *)scs_calloc(n_plus_m, sizeof(scs_float));
+  p->diag_r_idxs = (scs_int *)scs_calloc(n_plus_m, sizeof(scs_int));
   p->factorizations = 0;
   p->L->m = n_plus_m;
   p->L->n = n_plus_m;
   p->L->nz = -1;
-  p->kkt = permute_kkt(A, P, p, rho_y_vec);
+  p->kkt = permute_kkt(A, P, p, diag_r);
   ldl_prepare_status = ldl_prepare(p);
   ldl_status = ldl_factor(p, A->n);
   if (ldl_prepare_status < 0 || ldl_status < 0) {

data/vendor/scs/linsys/cpu/direct/private.h

@@ -18,12 +18,12 @@ struct SCS_LIN_SYS_WORK {
   scs_float *Dinv; /* inverse diagonal matrix of factorization */
   scs_int *perm;   /* permutation of KKT matrix for factorization */
   scs_float *bp;   /* workspace memory for solves */
-  scs_int *rho_y_vec_idxs;
+  scs_int *diag_r_idxs;
   scs_int factorizations;
   /* ldl factorization workspace */
   scs_float *D, *fwork;
   scs_int *etree, *iwork, *Lnz, *bwork;
-  scs_float rho_x;
+  scs_float *diag_p;
 };
 
 #ifdef __cplusplus

data/vendor/scs/linsys/cpu/indirect/private.c

@@ -17,7 +17,8 @@ char *SCS(get_lin_sys_summary)(ScsLinSysWork *p, const ScsInfo *info) {
 }
 */
 
-/* set M = inv ( diag ( rho_x * I + P + A' R_y^{-1} A ) ) */
+/* Not possible to do this on the fly due to M_ii += a_i' (R_y)^-1 a_i */
+/* set M = inv ( diag ( R_x + P + A' R_y^{-1} A ) ) */
 static void set_preconditioner(ScsLinSysWork *p) {
   scs_int i, k;
   scs_float *M = p->M;
@@ -28,22 +29,26 @@ static void set_preconditioner(ScsLinSysWork *p) {
   scs_printf("getting pre-conditioner\n");
 #endif
 
+  /* M_ii = (R_x)_i + P_ii + a_i' (R_y)^-1 a_i */
   for (i = 0; i < A->n; ++i) { /* cols */
-    M[i] = p->rho_x;
-    /* diag(A' R_y^{-1} A) */
+    /* M_ii = (R_x)_i */
+    M[i] = p->diag_r[i];
+    /* M_ii += a_i' (R_y)^-1 a_i */
     for (k = A->p[i]; k < A->p[i + 1]; ++k) {
       /* A->i[k] is row of entry k with value A->x[k] */
-      M[i] += A->x[k] * A->x[k] / p->rho_y_vec[A->i[k]];
+      M[i] += A->x[k] * A->x[k] / p->diag_r[A->n + A->i[k]];
     }
     if (P) {
       for (k = P->p[i]; k < P->p[i + 1]; k++) {
         /* diagonal element only */
         if (P->i[k] == i) { /* row == col */
+          /* M_ii += P_ii */
           M[i] += P->x[k];
           break;
         }
       }
     }
+    /* finally invert for pre-conditioner */
     M[i] = 1. / M[i];
   }
 #if VERBOSITY > 0
@@ -111,10 +116,18 @@ void SCS(free_lin_sys_work)(ScsLinSysWork *p) {
 }
 
 /* vec -> R_y^{-1} vec */
-static void scale_by_diag_r(scs_float *vec, ScsLinSysWork *p) {
+static void scale_by_r_y_inv(scs_float *vec, ScsLinSysWork *p) {
   scs_int i;
   for (i = 0; i < p->m; ++i) {
-    vec[i] /= p->rho_y_vec[i];
+    vec[i] /= p->diag_r[p->n + i];
+  }
+}
+
+/* y += R_x * x  */
+static void accum_by_r_x(scs_float *y, const scs_float *x, ScsLinSysWork *p) {
+  scs_int i;
+  for (i = 0; i < p->n; ++i) {
+    y[i] += p->diag_r[i] * x[i];
   }
 }
 
@@ -123,7 +136,7 @@ static void accum_by_a(ScsLinSysWork *p, const scs_float *x, scs_float *y) {
   SCS(accum_by_atrans)(p->At, x, y);
 }
 
-/* y = (rho_x * I + P + A' R_y^{-1} A) x */
+/* y = (R_x + P + A' R_y^{-1} A) x */
 static void mat_vec(const ScsMatrix *A, const ScsMatrix *P, ScsLinSysWork *p,
                     const scs_float *x, scs_float *y) {
   scs_float *z = p->tmp;
@@ -133,10 +146,10 @@ static void mat_vec(const ScsMatrix *A, const ScsMatrix *P, ScsLinSysWork *p,
     SCS(accum_by_p)(P, x, y); /* y = Px */
   }
   accum_by_a(p, x, z);           /* z = Ax */
-  scale_by_diag_r(z, p);         /* z = R_y^{-1} A x */
+  scale_by_r_y_inv(z, p);        /* z = R_y^{-1} A x */
   SCS(accum_by_atrans)(A, z, y); /* y += A'z, y = Px + A' R_y^{-1} Ax */
-  /* y = rho_x * x + Px + A' R_y^{-1} A x */
-  SCS(add_scaled_array)(y, x, A->n, p->rho_x);
+  /* y = R_x * x + Px + A' R_y^{-1} A * x */
+  accum_by_r_x(y, x, p);
 }
 
 static void apply_pre_conditioner(scs_float *z, scs_float *r, scs_int n,
@@ -149,36 +162,35 @@ static void apply_pre_conditioner(scs_float *z, scs_float *r, scs_int n,
 }
 
 /* no need to update anything in this case */
-void SCS(update_lin_sys_rho_y_vec)(ScsLinSysWork *p, scs_float *rho_y_vec) {
-  p->rho_y_vec = rho_y_vec; /* this isn't needed but do it to be safe */
+void SCS(update_lin_sys_diag_r)(ScsLinSysWork *p, const scs_float *diag_r) {
+  p->diag_r = diag_r; /* this isn't needed but do it to be safe */
   set_preconditioner(p);
 }
 
 ScsLinSysWork *SCS(init_lin_sys_work)(const ScsMatrix *A, const ScsMatrix *P,
-                                      scs_float *rho_y_vec, scs_float rho_x) {
+                                      const scs_float *diag_r) {
   ScsLinSysWork *p = (ScsLinSysWork *)scs_calloc(1, sizeof(ScsLinSysWork));
   p->A = A;
   p->P = P;
   p->m = A->m;
   p->n = A->n;
-  p->rho_x = rho_x;
 
-  p->p = (scs_float *)scs_malloc((A->n) * sizeof(scs_float));
-  p->r = (scs_float *)scs_malloc((A->n) * sizeof(scs_float));
-  p->Gp = (scs_float *)scs_malloc((A->n) * sizeof(scs_float));
-  p->tmp = (scs_float *)scs_malloc((A->m) * sizeof(scs_float));
+  p->p = (scs_float *)scs_calloc((A->n), sizeof(scs_float));
+  p->r = (scs_float *)scs_calloc((A->n), sizeof(scs_float));
+  p->Gp = (scs_float *)scs_calloc((A->n), sizeof(scs_float));
+  p->tmp = (scs_float *)scs_calloc((A->m), sizeof(scs_float));
 
   /* memory for A transpose */
-  p->At = (ScsMatrix *)scs_malloc(sizeof(ScsMatrix));
+  p->At = (ScsMatrix *)scs_calloc(1, sizeof(ScsMatrix));
   p->At->m = A->n;
   p->At->n = A->m;
-  p->At->i = (scs_int *)scs_malloc((A->p[A->n]) * sizeof(scs_int));
-  p->At->p = (scs_int *)scs_malloc((A->m + 1) * sizeof(scs_int));
-  p->At->x = (scs_float *)scs_malloc((A->p[A->n]) * sizeof(scs_float));
+  p->At->i = (scs_int *)scs_calloc((A->p[A->n]), sizeof(scs_int));
+  p->At->p = (scs_int *)scs_calloc((A->m + 1), sizeof(scs_int));
+  p->At->x = (scs_float *)scs_calloc((A->p[A->n]), sizeof(scs_float));
   transpose(A, p);
 
   /* preconditioner memory */
-  p->rho_y_vec = rho_y_vec;
+  p->diag_r = diag_r;
   p->z = (scs_float *)scs_calloc(A->n, sizeof(scs_float));
   p->M = (scs_float *)scs_calloc(A->n, sizeof(scs_float));
   set_preconditioner(p);
@@ -192,8 +204,7 @@ ScsLinSysWork *SCS(init_lin_sys_work)(const ScsMatrix *A, const ScsMatrix *P,
   return p;
 }
 
-/* solves (rho_x * I + P + A' R_y^{-1} A)x = b, s warm start, solution stored in
- * b */
+/* solves (R_x * I + P + A' R_y^{-1} A)x = b, s warm start, solution in b */
 static scs_int pcg(ScsLinSysWork *pr, const scs_float *s, scs_float *b,
                    scs_int max_its, scs_float tol) {
   scs_int i, n = pr->n;
@@ -268,14 +279,12 @@ static scs_int pcg(ScsLinSysWork *pr, const scs_float *s, scs_float *b,
 /* solves Mx = b, for x but stores result in b */
 /* s contains warm-start (if available) */
 /*
- * [x] = [rho_x I + P     A' ]^{-1} [rx]
- * [y]   [     A        -R_y ]      [ry]
- *
- * R_y = diag(rho_y_vec)
+ * [x] = [R_x + P     A' ]^{-1} [rx]
+ * [y]   [   A      -R_y ]      [ry]
  *
  * becomes:
  *
- * x = (rho_x I + P + A' R_y^{-1} A)^{-1} (rx + A' R_y^{-1} ry)
+ * x = (R_x + P + A' R_y^{-1} A)^{-1} (rx + A' R_y^{-1} ry)
  * y = R_y^{-1} (Ax - ry)
  *
  */
@@ -299,12 +308,12 @@ scs_int SCS(solve_lin_sys)(ScsLinSysWork *p, scs_float *b, const scs_float *s,
   /* tmp = ry */
   memcpy(p->tmp, &(b[p->n]), p->m * sizeof(scs_float));
   /* tmp = R_y^{-1} * ry */
-  scale_by_diag_r(p->tmp, p);
+  scale_by_r_y_inv(p->tmp, p);
   /* b[:n] = rx + A' R_y^{-1} ry */
   SCS(accum_by_atrans)(p->A, p->tmp, b);
   /* set max_iters to 10 * n (though in theory n is enough for any tol) */
   max_iters = 10 * p->n;
-  /* solves (rho_x I + P + A' R_y^{-1} A)x = b, s warm start, solution stored in
+  /* solves (R_x + P + A' R_y^{-1} A)x = b, s warm start, solution stored in
    * b */
   cg_its = pcg(p, s, b, max_iters, tol); /* b[:n] = x */
 
@@ -313,7 +322,7 @@ scs_int SCS(solve_lin_sys)(ScsLinSysWork *p, scs_float *b, const scs_float *s,
   /* b[n:] = Ax - ry */
   accum_by_a(p, b, &(b[p->n]));
   /* b[n:] = R_y^{-1} (Ax - ry) = y */
-  scale_by_diag_r(&(b[p->n]), p);
+  scale_by_r_y_inv(&(b[p->n]), p);
   p->tot_cg_its += cg_its;
 #if VERBOSITY > 1
   scs_printf("tol %.3e\n", tol);

data/vendor/scs/linsys/cpu/indirect/private.h

@@ -25,8 +25,7 @@ struct SCS_LIN_SYS_WORK {
   scs_float *M;
   /* reporting */
   scs_int tot_cg_its;
-  scs_float *rho_y_vec;
-  scs_float rho_x;
+  const scs_float *diag_r;
 };
 
 #ifdef __cplusplus

data/vendor/scs/linsys/csparse.c

@@ -12,9 +12,9 @@ csc *SCS(cs_spalloc)(scs_int m, scs_int n, scs_int nzmax, scs_int values,
   A->n = n;
   A->nzmax = nzmax = MAX(nzmax, 1);
   A->nz = triplet ? 0 : -1; /* allocate triplet or comp.col */
-  A->p = (scs_int *)scs_malloc((triplet ? nzmax : n + 1) * sizeof(scs_int));
-  A->i = (scs_int *)scs_malloc(nzmax * sizeof(scs_int));
-  A->x = values ? (scs_float *)scs_malloc(nzmax * sizeof(scs_float)) : SCS_NULL;
+  A->p = (scs_int *)scs_calloc((triplet ? nzmax : n + 1), sizeof(scs_int));
+  A->i = (scs_int *)scs_calloc(nzmax, sizeof(scs_int));
+  A->x = values ? (scs_float *)scs_calloc(nzmax, sizeof(scs_float)) : SCS_NULL;
   return (!A->p || !A->i || (values && !A->x)) ? SCS(cs_spfree)(A) : A;
 }