scs 0.3.1 → 0.3.2

data/vendor/scs/include/scs.h

@@ -1,3 +1,6 @@
+/* This file contains the outward facing SCS API. */
+/* It includes all the input/output data structs and the API functions. */
+
 #ifndef SCS_H_GUARD
 #define SCS_H_GUARD
 
@@ -5,20 +8,34 @@
 extern "C" {
 #endif
 
-#include <string.h>
+/* Contains definitions of primitive types `scs_int` and `scs_float`. */
+#include "scs_types.h"
 
-#include "aa.h"
-#include "glbopts.h"
+/* The following abstract structs are implemented later. */
 
 /** Struct containing acceleration workspace. Implemented by acceleration. */
-typedef struct SCS_ACCEL_WORK ScsAccelWork;
+typedef struct ACCEL_WORK AaWork;
 /** Struct containing cone projection workspace. Implemented by cones. */
 typedef struct SCS_CONE_WORK ScsConeWork;
 /** Struct containing linear system workspace. Implemented by linear solver. */
 typedef struct SCS_LIN_SYS_WORK ScsLinSysWork;
+/** Struct containing SCS workspace. Implemented in `scs_work.h`. */
+typedef struct SCS_WORK ScsWork;
+
+/* SCS returns one of the following integer exit flags:            */
+#define SCS_INFEASIBLE_INACCURATE (-7)
+#define SCS_UNBOUNDED_INACCURATE (-6)
+#define SCS_SIGINT (-5)
+#define SCS_FAILED (-4)
+#define SCS_INDETERMINATE (-3)
+#define SCS_INFEASIBLE (-2) /* primal infeasible, dual unbounded   */
+#define SCS_UNBOUNDED (-1)  /* primal unbounded, dual infeasible   */
+#define SCS_UNFINISHED (0)  /* never returned, used as placeholder */
+#define SCS_SOLVED (1)
+#define SCS_SOLVED_INACCURATE (2)
 
-/** This defines the data matrices which should be supplied in column compressed
- *  format with zero based indexing.
+/** This defines the data matrices which should be supplied in compressed
+ *  sparse column format with zero based indexing.
  */
 typedef struct {
   /** Matrix values, size: number of non-zeros. */
@@ -120,7 +137,10 @@ typedef struct {
 
 /** Contains primal-dual solution arrays or a certificate of infeasibility.
  *  Check the exit flag to determine whether this contains a solution or a
- *  certificate. */
+ *  certificate. If when passed into SCS the members `x`, `y`, `s` are
+ *  NULL then SCS will allocate memory for them which should be managed
+ *  by the user to prevent memory leaks.
+ */
 typedef struct {
   /** Primal variable. */
   scs_float *x;
@@ -136,6 +156,8 @@ typedef struct {
   scs_int iter;
   /** Status string, e.g. 'solved'. */
   char status[128];
+  /** Linear system solver used. */
+  char lin_sys_solver[128];
   /** Status as scs_int, defined in glbopts.h. */
   scs_int status_val;
   /** Number of updates to scale. */
@@ -176,78 +198,8 @@ typedef struct {
   scs_float accel_time;
 } ScsInfo;
 
-/* the following structs are not exposed to user */
-
-/** Contains normalization variables. */
-typedef struct {
-  scs_float *D, *E; /* for normalization */
-  scs_float primal_scale, dual_scale;
-} ScsScaling;
-
-/** Holds residual information. */
-typedef struct {
-  scs_int last_iter;
-  scs_float xt_p_x;     /* x' P x  */
-  scs_float xt_p_x_tau; /* x'Px * tau^2 *not* divided out */
-  scs_float ctx;
-  scs_float ctx_tau; /* tau *not* divided out */
-  scs_float bty;
-  scs_float bty_tau; /* tau *not* divided out */
-  scs_float pobj;    /* primal objective */
-  scs_float dobj;    /* dual objective */
-  scs_float gap;     /* pobj - dobj */
-  scs_float tau;
-  scs_float kap;
-  scs_float res_pri;
-  scs_float res_dual;
-  scs_float res_infeas;
-  scs_float res_unbdd_p;
-  scs_float res_unbdd_a;
-  /* tau NOT divided out */
-  scs_float *ax, *ax_s, *px, *aty, *ax_s_btau, *px_aty_ctau;
-} ScsResiduals;
-
-/** Workspace for SCS */
-typedef struct {
-  /* x_prev = x from previous iteration */
-  scs_int time_limit_reached; /* set if the time-limit is reached */
-  scs_float *u, *u_t;
-  scs_float *v, *v_prev;
-  scs_float *rsk;                /* rsk [ r; s; kappa ] */
-  scs_float *h;                  /* h = [c; b] */
-  scs_float *g;                  /* g = (I + M)^{-1} h */
-  scs_float *lin_sys_warm_start; /* linear system warm-start (indirect only) */
-  scs_float *rho_y_vec; /* vector of rho y parameters (affects cone project) */
-  AaWork *accel;        /* struct for acceleration workspace */
-  scs_float *b_orig, *c_orig;             /* original b and c vectors */
-  scs_float *b_normalized, *c_normalized; /* normalized b and c vectors */
-  scs_int m, n;                           /* A has m rows, n cols */
-  ScsMatrix *A;                           /* (possibly normalized) A matrix */
-  ScsMatrix *P;                           /* (possibly normalized) P matrix */
-  ScsLinSysWork *p;            /* struct populated by linear system solver */
-  ScsScaling *scal;            /* contains the re-scaling data */
-  ScsConeWork *cone_work;      /* workspace for the cone projection step */
-  scs_int *cone_boundaries;    /* array with boundaries of cones */
-  scs_int cone_boundaries_len; /* total length of cones */
-  /* normalized and unnormalized residuals */
-  ScsResiduals *r_orig, *r_normalized;
-  /* track x,y,s as alg progresses, tau *not* divided out */
-  ScsSolution *xys_orig, *xys_normalized;
-  /* updating scale params workspace */
-  scs_float sum_log_scale_factor;
-  scs_int last_scale_update_iter, n_log_scale_factor, scale_updates;
-  /* aa norm stat */
-  scs_float aa_norm;
-  scs_int rejected_accel_steps, accepted_accel_steps;
-  scs_float setup_time; /* time taken for setup phase (milliseconds) */
-  scs_float scale;      /* current scale parameter */
-  const ScsData *d;
-  const ScsCone *k;
-  const ScsSettings *stgs; /* contains solver settings specified by user */
-} ScsWork;
-
 /*
- * main library API
+ * Main library API.
  */
 
 /**
@@ -270,24 +222,24 @@ typedef struct {
  * @param  stgs  SCS solver settings.
  * @return       Solver work struct.
  */
-ScsWork *SCS(init)(const ScsData *d, const ScsCone *k, const ScsSettings *stgs);
+ScsWork *scs_init(const ScsData *d, const ScsCone *k, const ScsSettings *stgs);
 
 /**
- * Solve quadratic cone program initialized by SCS(init).
+ * Solve quadratic cone program initialized by scs_init.
  *
  * @param  w     Workspace allocated by init.
  * @param  sol 	 Solver solution struct, will contain solution at termination.
  * @param  info  Solver info reporting.
  * @return       Flag containing problem status (see \a glbopts.h).
  */
-scs_int SCS(solve)(ScsWork *w, ScsSolution *sol, ScsInfo *info);
+scs_int scs_solve(ScsWork *w, ScsSolution *sol, ScsInfo *info);
 
 /**
  * Clean up allocated SCS workspace.
  *
  * @param  w  Workspace allocated by init, will be deallocated.
  */
-void SCS(finish)(ScsWork *w);
+void scs_finish(ScsWork *w);
 
 /**
  * Solve quadratic cone program defined by data in d and cone k.
@@ -297,7 +249,8 @@ void SCS(finish)(ScsWork *w);
  * @param  d 		 Problem data.
  * @param  k 		 Cone data.
  * @param  stgs  SCS solver settings.
- * @param  sol   Solution will be stored here.
+ * @param  sol   Solution will be stored here. If members `x`, `y`, `s` are
+ *               NULL then SCS will allocate memory for them.
  * @param  info  Information about the solve will be stored here.
  * @return       Flag that determines solve type (see \a glbopts.h).
  */
@@ -309,11 +262,14 @@ scs_int scs(const ScsData *d, const ScsCone *k, const ScsSettings *stgs,
  *
  * @param  stgs  Settings struct that will be populated.
  */
-void SCS(set_default_settings)(ScsSettings *stgs);
+void scs_set_default_settings(ScsSettings *stgs);
 
-const char *SCS(version)(void);
-size_t SCS(sizeof_int)(void);
-size_t SCS(sizeof_float)(void);
+/**
+ * Helper function simply returns the current version of SCS as a string.
+ *
+ * @return       SCS version as a string.
+ */
+const char *scs_version(void);
 
 #ifdef __cplusplus
 }

data/vendor/scs/include/scs_types.h

@@ -0,0 +1,34 @@
+/*
+ * Definitions of primitive types used in SCS.
+ */
+
+#ifndef SCS_TYPES_H_GUARD
+#define SCS_TYPES_H_GUARD
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef DLONG
+/*#ifdef _WIN64
+#include <stdint.h>
+typedef int64_t scs_int;
+#else
+typedef long scs_int;
+#endif
+*/
+typedef long long scs_int;
+#else
+typedef int scs_int;
+#endif
+
+#ifndef SFLOAT
+typedef double scs_float;
+#else
+typedef float scs_float;
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif

data/vendor/scs/include/scs_work.h

@@ -0,0 +1,83 @@
+/*
+ * Define ScsWork and related internal-only structs (not part of external API).
+ */
+
+#ifndef SCS_WORK_H_GUARD
+#define SCS_WORK_H_GUARD
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** Contains normalization variables. */
+typedef struct {
+  scs_float *D, *E; /* for normalization */
+  scs_int m;        /* Length of D */
+  scs_int n;        /* Length of E */
+  scs_float primal_scale, dual_scale;
+} ScsScaling;
+
+/** Holds residual information. */
+typedef struct {
+  scs_int last_iter;
+  scs_float xt_p_x;     /* x' P x  */
+  scs_float xt_p_x_tau; /* x'Px * tau^2 *not* divided out */
+  scs_float ctx;
+  scs_float ctx_tau; /* tau *not* divided out */
+  scs_float bty;
+  scs_float bty_tau; /* tau *not* divided out */
+  scs_float pobj;    /* primal objective */
+  scs_float dobj;    /* dual objective */
+  scs_float gap;     /* pobj - dobj */
+  scs_float tau;
+  scs_float kap;
+  scs_float res_pri;
+  scs_float res_dual;
+  scs_float res_infeas;
+  scs_float res_unbdd_p;
+  scs_float res_unbdd_a;
+  /* tau NOT divided out */
+  scs_float *ax, *ax_s, *px, *aty, *ax_s_btau, *px_aty_ctau;
+} ScsResiduals;
+
+/** Workspace for SCS */
+struct SCS_WORK {
+  /* x_prev = x from previous iteration */
+  scs_int time_limit_reached; /* set if the time-limit is reached */
+  scs_float *u, *u_t;
+  scs_float *v, *v_prev;
+  scs_float *rsk;                /* rsk [ r; s; kappa ] */
+  scs_float *h;                  /* h = [c; b] */
+  scs_float *g;                  /* g = (I + M)^{-1} h */
+  scs_float *lin_sys_warm_start; /* linear system warm-start (indirect only) */
+  scs_float *diag_r; /* vector of R matrix diagonals (affects cone proj) */
+  AaWork *accel;     /* struct for acceleration workspace */
+  scs_float *b_orig, *c_orig;             /* original b and c vectors */
+  scs_float *b_normalized, *c_normalized; /* normalized b and c vectors */
+  scs_int m, n;                           /* A has m rows, n cols */
+  ScsMatrix *A;                           /* (possibly normalized) A matrix */
+  ScsMatrix *P;                           /* (possibly normalized) P matrix */
+  ScsLinSysWork *p;       /* struct populated by linear system solver */
+  ScsScaling *scal;       /* contains the re-scaling data */
+  ScsConeWork *cone_work; /* workspace for the cone projection step */
+  /* normalized and unnormalized residuals */
+  ScsResiduals *r_orig, *r_normalized;
+  /* track x,y,s as alg progresses, tau *not* divided out */
+  ScsSolution *xys_orig, *xys_normalized;
+  /* updating scale params workspace */
+  scs_float sum_log_scale_factor;
+  scs_int last_scale_update_iter, n_log_scale_factor, scale_updates;
+  /* aa norm stat */
+  scs_float aa_norm;
+  scs_int rejected_accel_steps, accepted_accel_steps;
+  scs_float setup_time; /* time taken for setup phase (milliseconds) */
+  scs_float scale;      /* current scale parameter */
+  const ScsData *d;
+  const ScsCone *k;
+  const ScsSettings *stgs; /* contains solver settings specified by user */
+};
+
+#ifdef __cplusplus
+}
+#endif
+#endif

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