scs 0.3.2 → 0.4.1

data/vendor/scs/linsys/external/amd/SuiteSparse_config.c

@@ -50,7 +50,9 @@
 
 struct SuiteSparse_config_struct SuiteSparse_config =
 {
-    scs_malloc, scs_calloc, scs_realloc, scs_free, _scs_printf,
+    scs_malloc, scs_calloc, scs_realloc, scs_free,
+    /* Disable printing */
+    SCS_NULL,
     SuiteSparse_hypot,
     SuiteSparse_divcomplex
 
@@ -79,7 +81,7 @@ void SuiteSparse_start ( void )
     SuiteSparse_config.calloc_func  = scs_calloc ;
     SuiteSparse_config.realloc_func = scs_realloc ;
     SuiteSparse_config.free_func    = scs_free ;
-    SuiteSparse_config.printf_func  = _scs_printf ;
+    SuiteSparse_config.printf_func  = SCS_NULL;
     /* math functions */
     SuiteSparse_config.hypot_func = SuiteSparse_hypot ;
     SuiteSparse_config.divcomplex_func = SuiteSparse_divcomplex ;

data/vendor/scs/linsys/external/amd/SuiteSparse_config.h

@@ -71,11 +71,6 @@ extern "C" {
 #define SuiteSparse_long_id "%" SuiteSparse_long_idd
 #endif
 
-#ifndef _scs_printf
-#define _scs_printf scs_printf
-#endif
-
-
 /* ========================================================================== */
 /* === SuiteSparse_config parameters and functions ========================== */
 /* ========================================================================== */

data/vendor/scs/linsys/gpu/gpu.c

@@ -19,13 +19,13 @@ void SCS(accum_by_atrans_gpu)(const ScsGpuMatrix *Ag,
     if (*buffer != SCS_NULL) {
       cudaFree(*buffer);
     }
-    cudaMalloc(buffer, *buffer_size);
+    cudaMalloc(buffer, new_buffer_size);
     *buffer_size = new_buffer_size;
   }
 
   CUSPARSE_GEN(SpMV)
   (cusparse_handle, CUSPARSE_OPERATION_NON_TRANSPOSE, &onef, Ag->descr, x,
-   &onef, y, SCS_CUDA_FLOAT, SCS_CSRMV_ALG, buffer);
+   &onef, y, SCS_CUDA_FLOAT, SCS_CSRMV_ALG, *buffer);
 }
 
 /* this is slow, use trans routine if possible */
@@ -48,13 +48,13 @@ void SCS(accum_by_a_gpu)(const ScsGpuMatrix *Ag, const cusparseDnVecDescr_t x,
     if (*buffer != SCS_NULL) {
       cudaFree(*buffer);
     }
-    cudaMalloc(buffer, *buffer_size);
+    cudaMalloc(buffer, new_buffer_size);
     *buffer_size = new_buffer_size;
   }
 
   CUSPARSE_GEN(SpMV)
   (cusparse_handle, CUSPARSE_OPERATION_TRANSPOSE, &onef, Ag->descr, x, &onef, y,
-   SCS_CUDA_FLOAT, SCS_CSRMV_ALG, buffer);
+   SCS_CUDA_FLOAT, SCS_CSRMV_ALG, *buffer);
 }
 
 /* This assumes that P has been made full (ie not triangular) and uses the

data/vendor/scs/linsys/gpu/gpu.h

@@ -74,7 +74,7 @@ extern "C" {
 #define SCS_CUSPARSE_INDEX CUSPARSE_INDEX_64I
 #endif
 
-#define SCS_CSRMV_ALG CUSPARSE_CSRMV_ALG1
+#define SCS_CSRMV_ALG CUSPARSE_SPMV_CSR_ALG1
 #define SCS_CSR2CSC_ALG CUSPARSE_CSR2CSC_ALG1
 
 /*

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

@@ -21,20 +21,10 @@ static scs_float cg_gpu_norm(cublasHandle_t cublas_handle, scs_float *r,
   return nrm;
 }
 
-const char *SCS(get_lin_sys_method)() {
+const char *scs_get_lin_sys_method() {
   return "sparse-indirect GPU";
 }
 
-/*
-char *SCS(get_lin_sys_summary)(ScsLinSysWork *p, const ScsInfo *info) {
-  char *str = (char *)scs_malloc(sizeof(char) * 128);
-  sprintf(str, "lin-sys: avg cg its: %2.2f\n",
-          (scs_float)p->tot_cg_its / (info->iter + 1));
-  p->tot_cg_its = 0;
-  return str;
-}
-*/
-
 /* 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, const scs_float *diag_r) {
@@ -76,7 +66,7 @@ static void set_preconditioner(ScsLinSysWork *p, const scs_float *diag_r) {
 }
 
 /* no need to update anything in this case */
-void SCS(update_lin_sys_diag_r)(ScsLinSysWork *p, const scs_float *diag_r) {
+void scs_update_lin_sys_diag_r(ScsLinSysWork *p, const scs_float *diag_r) {
   scs_int i;
 
   /* R_x to gpu */
@@ -93,7 +83,7 @@ void SCS(update_lin_sys_diag_r)(ScsLinSysWork *p, const scs_float *diag_r) {
   set_preconditioner(p, diag_r);
 }
 
-void SCS(free_lin_sys_work)(ScsLinSysWork *p) {
+void scs_free_lin_sys_work(ScsLinSysWork *p) {
   if (p) {
     scs_free(p->M);
     scs_free(p->inv_r_y);
@@ -182,13 +172,13 @@ static void mat_vec(ScsLinSysWork *p, const scs_float *x, scs_float *y) {
 }
 
 /* P comes in upper triangular, expand to full
- * First compute triplet version of full matrix, then compress to csc
+ * First compute triplet version of full matrix, then compress to CSC
  * */
-static csc *fill_p_matrix(const ScsMatrix *P) {
+static ScsMatrix *fill_p_matrix(const ScsMatrix *P) {
   scs_int i, j, k, kk;
   scs_int Pnzmax = 2 * P->p[P->n]; /* upper bound */
-  csc *P_tmp = SCS(cs_spalloc)(P->n, P->n, Pnzmax, 1, 1);
-  csc *P_full;
+  ScsMatrix *P_tmp = SCS(cs_spalloc)(P->n, P->n, Pnzmax, 1, 1);
+  ScsMatrix *P_full;
   kk = 0;
   for (j = 0; j < P->n; j++) { /* cols */
     for (k = P->p[j]; k < P->p[j + 1]; k++) {
@@ -209,16 +199,15 @@ static csc *fill_p_matrix(const ScsMatrix *P) {
       kk++;
     }
   }
-  P_tmp->nz = kk; /* set number of nonzeros */
-  P_full = SCS(cs_compress)(P_tmp, SCS_NULL);
+  P_full = SCS(cs_compress)(P_tmp, kk, SCS_NULL);
   SCS(cs_spfree)(P_tmp);
   return P_full;
 }
 
-ScsLinSysWork *SCS(init_lin_sys_work)(const ScsMatrix *A, const ScsMatrix *P,
-                                      const scs_float *diag_r) {
+ScsLinSysWork *scs_init_lin_sys_work(const ScsMatrix *A, const ScsMatrix *P,
+                                     const scs_float *diag_r) {
   cudaError_t err;
-  csc *P_full;
+  ScsMatrix *P_full;
   ScsLinSysWork *p = SCS_NULL;
   ScsGpuMatrix *Ag = SCS_NULL;
   ScsGpuMatrix *Pg = SCS_NULL;
@@ -324,7 +313,7 @@ ScsLinSysWork *SCS(init_lin_sys_work)(const ScsMatrix *A, const ScsMatrix *P,
   cusparseCreateDnVec(&p->dn_vec_m, Ag->m, p->tmp_m, SCS_CUDA_FLOAT);
 
   /* Form preconditioner and copy R_x, 1/R_y to gpu */
-  SCS(update_lin_sys_diag_r)(p, diag_r);
+  scs_update_lin_sys_diag_r(p, diag_r);
 
 #if GPU_TRANSPOSE_MAT > 0
   p->Agt = (ScsGpuMatrix *)scs_malloc(sizeof(ScsGpuMatrix));
@@ -367,7 +356,7 @@ ScsLinSysWork *SCS(init_lin_sys_work)(const ScsMatrix *A, const ScsMatrix *P,
   if (err != cudaSuccess) {
     printf("%s:%d:%s\nERROR_CUDA (*): %s\n", __FILE__, __LINE__, __func__,
            cudaGetErrorString(err));
-    SCS(free_lin_sys_work)(p);
+    scs_free_lin_sys_work(p);
     return SCS_NULL;
   }
   return p;
@@ -466,8 +455,8 @@ static scs_int pcg(ScsLinSysWork *pr, const scs_float *s, scs_float *bg,
  * y = R_y^{-1} (Ax - ry)
  *
  */
-scs_int SCS(solve_lin_sys)(ScsLinSysWork *p, scs_float *b, const scs_float *s,
-                           scs_float tol) {
+scs_int scs_solve_lin_sys(ScsLinSysWork *p, scs_float *b, const scs_float *s,
+                          scs_float tol) {
   scs_int cg_its, max_iters;
   scs_float neg_onef = -1.0;
 

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

@@ -0,0 +1,182 @@
+#include "private.h"
+
+#define PARDISO_SYMBOLIC (11)
+#define PARDISO_NUMERIC (22)
+#define PARDISO_SOLVE (33)
+#define PARDISO_CLEANUP (-1)
+
+/* TODO: is it necessary to use pardiso_64 and MKL_Set_Interface_Layer ? */
+/*
+#define MKL_INTERFACE_LP64 0
+#define MKL_INTERFACE_ILP64 1
+*/
+#ifdef DLONG
+#define _PARDISO pardiso_64
+#else
+#define _PARDISO pardiso
+#endif
+
+/* Prototypes for Pardiso functions */
+void _PARDISO(void **pt, const scs_int *maxfct, const scs_int *mnum,
+              const scs_int *mtype, const scs_int *phase, const scs_int *n,
+              const scs_float *a, const scs_int *ia, const scs_int *ja,
+              scs_int *perm, const scs_int *nrhs, scs_int *iparm,
+              const scs_int *msglvl, scs_float *b, scs_float *x,
+              scs_int *error);
+/* scs_int MKL_Set_Interface_Layer(scs_int); */
+
+const char *scs_get_lin_sys_method() {
+  return "sparse-direct-mkl-pardiso";
+}
+
+void scs_free_lin_sys_work(ScsLinSysWork *p) {
+  if (p) {
+    p->phase = PARDISO_CLEANUP;
+    _PARDISO(p->pt, &(p->maxfct), &(p->mnum), &(p->mtype), &(p->phase),
+             &(p->n_plus_m), SCS_NULL, p->kkt->p, p->kkt->i, SCS_NULL,
+             &(p->nrhs), p->iparm, &(p->msglvl), SCS_NULL, SCS_NULL,
+             &(p->error));
+    if (p->error != 0) {
+      scs_printf("Error during MKL Pardiso cleanup: %d", (int)p->error);
+    }
+    if (p->kkt)
+      SCS(cs_spfree)(p->kkt);
+    if (p->sol)
+      scs_free(p->sol);
+    if (p->diag_r_idxs)
+      scs_free(p->diag_r_idxs);
+    if (p->diag_p)
+      scs_free(p->diag_p);
+    scs_free(p);
+  }
+}
+
+ScsLinSysWork *scs_init_lin_sys_work(const ScsMatrix *A, const ScsMatrix *P,
+                                     const scs_float *diag_r) {
+  scs_int i;
+  ScsLinSysWork *p = scs_calloc(1, sizeof(ScsLinSysWork));
+
+  /* TODO: is this necessary with pardiso_64? */
+  /* Set MKL interface layer */
+  /*
+#ifdef DLONG
+  MKL_Set_Interface_Layer(MKL_INTERFACE_ILP64);
+#else
+  MKL_Set_Interface_Layer(MKL_INTERFACE_LP64);
+#endif
+  */
+  p->n = A->n;
+  p->m = A->m;
+  p->n_plus_m = p->n + p->m;
+
+  /* Even though we overwrite rhs with sol pardiso requires the memory */
+  p->sol = (scs_float *)scs_malloc(sizeof(scs_float) * p->n_plus_m);
+  p->diag_r_idxs = (scs_int *)scs_calloc(p->n_plus_m, sizeof(scs_int));
+  p->diag_p = (scs_float *)scs_calloc(p->n, sizeof(scs_float));
+
+  /* MKL pardiso requires upper triangular CSR matrices. The KKT matrix stuffed
+   * as CSC lower triangular is equivalent. Pass upper=0. */
+  p->kkt = SCS(form_kkt)(A, P, p->diag_p, diag_r, p->diag_r_idxs, 0);
+  if (!(p->kkt)) {
+    scs_printf("Error in forming KKT matrix");
+    scs_free_lin_sys_work(p);
+    return SCS_NULL;
+  }
+
+  for (i = 0; i < 64; i++) {
+    p->iparm[i] = 0; /* Setup Pardiso control parameters */
+    p->pt[i] = 0;    /* Initialize the internal solver memory pointer */
+  }
+
+  /* Set Pardiso variables */
+  p->mtype = -2;         /* Real symmetric indefinite matrix */
+  p->nrhs = 1;           /* Number of right hand sides */
+  p->maxfct = 1;         /* Maximum number of numerical factorizations */
+  p->mnum = 1;           /* Which factorization to use */
+  p->error = 0;          /* Initialize error flag */
+  p->msglvl = VERBOSITY; /* Printing information */
+
+  /* For all iparm vars see MKL documentation */
+  p->iparm[0] = 1;          /* Parsido must inspect iparm */
+  p->iparm[1] = 3;          /* Fill-in reordering from OpenMP */
+  p->iparm[5] = 1;          /* Write solution into b */
+  p->iparm[7] = 0;          /* Automatic iterative refinement calculation */
+  p->iparm[9] = 8;          /* Perturb the pivot elements with 1E-8 */
+  p->iparm[34] = 1;         /* Use C-style indexing for indices */
+  /* p->iparm[36] = -80; */ /* Form block sparse matrices */
+
+#ifdef SFLOAT
+  p->iparm[27] = 1; /* 1 is single precision, 0 is double */
+#endif
+
+  /* Permutation and symbolic factorization */
+  scs_int phase = PARDISO_SYMBOLIC;
+  _PARDISO(p->pt, &(p->maxfct), &(p->mnum), &(p->mtype), &phase, &(p->n_plus_m),
+           p->kkt->x, p->kkt->p, p->kkt->i, SCS_NULL, &(p->nrhs), p->iparm,
+           &(p->msglvl), SCS_NULL, SCS_NULL, &(p->error));
+
+  if (p->error != 0) {
+    scs_printf("Error during symbolic factorization: %d", (int)p->error);
+    scs_free_lin_sys_work(p);
+    return SCS_NULL;
+  }
+
+  /* Numerical factorization */
+  p->phase = PARDISO_NUMERIC;
+  _PARDISO(p->pt, &(p->maxfct), &(p->mnum), &(p->mtype), &(p->phase),
+           &(p->n_plus_m), p->kkt->x, p->kkt->p, p->kkt->i, SCS_NULL,
+           &(p->nrhs), p->iparm, &(p->msglvl), SCS_NULL, SCS_NULL, &(p->error));
+
+  if (p->error) {
+    scs_printf("Error during numerical factorization: %d", (int)p->error);
+    scs_free_lin_sys_work(p);
+    return SCS_NULL;
+  }
+
+  if (p->iparm[21] < p->n) {
+    scs_printf("KKT matrix has < n positive eigenvalues. P not PSD.");
+    return SCS_NULL;
+  }
+
+  return p;
+}
+
+/* Returns solution to linear system Ax = b with solution stored in b */
+scs_int scs_solve_lin_sys(ScsLinSysWork *p, scs_float *b, const scs_float *ws,
+                          scs_float tol) {
+  /* Back substitution and iterative refinement */
+  p->phase = PARDISO_SOLVE;
+  _PARDISO(p->pt, &(p->maxfct), &(p->mnum), &(p->mtype), &(p->phase),
+           &(p->n_plus_m), p->kkt->x, p->kkt->p, p->kkt->i, SCS_NULL,
+           &(p->nrhs), p->iparm, &(p->msglvl), b, p->sol, &(p->error));
+  if (p->error != 0) {
+    scs_printf("Error during linear system solution: %d", (int)p->error);
+  }
+  return p->error;
+}
+
+/* Update factorization when R changes */
+void scs_update_lin_sys_diag_r(ScsLinSysWork *p, const scs_float *diag_r) {
+  scs_int 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];
+  }
+
+  /* Perform numerical factorization */
+  p->phase = PARDISO_NUMERIC;
+  _PARDISO(p->pt, &(p->maxfct), &(p->mnum), &(p->mtype), &(p->phase),
+           &(p->n_plus_m), p->kkt->x, p->kkt->p, p->kkt->i, SCS_NULL,
+           &(p->nrhs), p->iparm, &(p->msglvl), SCS_NULL, SCS_NULL, &(p->error));
+
+  if (p->error != 0) {
+    scs_printf("Error in PARDISO factorization when updating: %d.\n",
+               (int)p->error);
+    scs_free_lin_sys_work(p);
+  }
+}

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

@@ -0,0 +1,38 @@
+#ifndef PRIV_H_GUARD
+#define PRIV_H_GUARD
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "csparse.h"
+#include "linsys.h"
+
+struct SCS_LIN_SYS_WORK {
+  ScsMatrix *kkt; /* Upper triangular KKT matrix (in CSR format) */
+  scs_float *sol; /* solution to the KKT system */
+  scs_int n;      /* number of QP variables */
+  scs_int m;      /* number of QP constraints */
+
+  /* Pardiso variables */
+  void *pt[64];      /* internal solver memory pointer pt */
+  scs_int iparm[64]; /* Pardiso control parameters */
+  scs_int n_plus_m;  /* dimension of the linear system */
+  scs_int mtype;     /* matrix type (-2 for real and symmetric indefinite) */
+  scs_int nrhs;      /* number of right-hand sides (1) */
+  scs_int maxfct;    /* maximum number of factors (1) */
+  scs_int mnum;      /* indicates matrix for the solution phase (1) */
+  scs_int phase;     /* control the execution phases of the solver */
+  scs_int error;     /* the error indicator (0 for no error) */
+  scs_int msglvl;    /* Message level information (0 for no output) */
+
+  /* These are required for matrix updates */
+  scs_int *diag_r_idxs; /* indices where R appears */
+  scs_float *diag_p;    /* Diagonal values of P */
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/vendor/scs/linsys/scs_matrix.c

@@ -10,6 +10,10 @@
 #define NUM_L2_PASSES (1)    /* do one or zero, not more since not stable */
 
 scs_int SCS(copy_matrix)(ScsMatrix **dstp, const ScsMatrix *src) {
+  if (!src) {
+    *dstp = SCS_NULL;
+    return 1;
+  }
   scs_int Anz = src->p[src->n];
   ScsMatrix *A = (ScsMatrix *)scs_calloc(1, sizeof(ScsMatrix));
   if (!A) {
@@ -41,6 +45,8 @@ scs_int SCS(validate_lin_sys)(const ScsMatrix *A, const ScsMatrix *P) {
   }
   /* 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]) {
@@ -53,6 +59,7 @@ scs_int SCS(validate_lin_sys)(const ScsMatrix *A, const ScsMatrix *P) {
       }
     }
   }
+  */
   if (((scs_float)Anz / A->m > A->n) || (Anz < 0)) {
     scs_printf("Anz (nonzeros in A) = %li, outside of valid range\n",
                (long)Anz);
@@ -106,18 +113,18 @@ static inline scs_float apply_limit(scs_float x) {
   return x;
 }
 
-static void compute_ruiz_mats(ScsMatrix *P, ScsMatrix *A, scs_float *b,
-                              scs_float *c, scs_float *Dt, scs_float *Et,
-                              scs_float *s, ScsConeWork *cone) {
+static void compute_ruiz_mats(ScsMatrix *P, ScsMatrix *A, scs_float *Dt,
+                              scs_float *Et, ScsConeWork *cone) {
   scs_int i, j, kk;
   scs_float wrk;
+  scs_float nm_a_col;
 
   /****************************  D  ****************************/
 
   /* initialize D */
   for (i = 0; i < A->m; ++i) {
-    /* Dt[i] = 0.; */
-    Dt[i] = ABS(b[i]);
+    Dt[i] = 0.;
+    /* Dt[i] = ABS(b[i]); */
   }
 
   /* calculate row norms */
@@ -132,15 +139,16 @@ static void compute_ruiz_mats(ScsMatrix *P, ScsMatrix *A, scs_float *b,
 
   /* invert temporary vec to form D */
   for (i = 0; i < A->m; ++i) {
-    Dt[i] = SAFEDIV_POS(1.0, SQRTF(apply_limit(Dt[i])));
+    Dt[i] = SQRTF(apply_limit(Dt[i]));
+    Dt[i] = SAFEDIV_POS(1.0, Dt[i]);
   }
 
   /****************************  E  ****************************/
 
   /* initialize E */
   for (i = 0; i < A->n; ++i) {
-    /* Et[i] = 0.; */
-    Et[i] = ABS(c[i]);
+    Et[i] = 0.;
+    /* Et[i] = ABS(c[i]); */
   }
 
   /* TODO: test not using P to determine scaling  */
@@ -163,27 +171,24 @@ static void compute_ruiz_mats(ScsMatrix *P, ScsMatrix *A, scs_float *b,
 
   /* calculate col norms, E */
   for (i = 0; i < A->n; ++i) {
-    Et[i] = MAX(Et[i], SCS(norm_inf)(&(A->x[A->p[i]]), A->p[i + 1] - A->p[i]));
-    Et[i] = SAFEDIV_POS(1.0, SQRTF(apply_limit(Et[i])));
+    nm_a_col = SCS(norm_inf)(&(A->x[A->p[i]]), A->p[i + 1] - A->p[i]);
+    Et[i] = MAX(Et[i], nm_a_col);
+    Et[i] = SQRTF(apply_limit(Et[i]));
+    Et[i] = SAFEDIV_POS(1.0, Et[i]);
   }
-
-  /* calculate s value */
-  *s = MAX(SCS(norm_inf)(c, A->n), SCS(norm_inf)(b, A->m));
-  *s = SAFEDIV_POS(1.0, SQRTF(apply_limit(*s)));
 }
 
-static void compute_l2_mats(ScsMatrix *P, ScsMatrix *A, scs_float *b,
-                            scs_float *c, scs_float *Dt, scs_float *Et,
-                            scs_float *s, ScsConeWork *cone) {
+static void compute_l2_mats(ScsMatrix *P, ScsMatrix *A, scs_float *Dt,
+                            scs_float *Et, ScsConeWork *cone) {
   scs_int i, j, kk;
-  scs_float wrk, norm_c, norm_b;
+  scs_float wrk;
 
   /****************************  D  ****************************/
 
   /* initialize D */
   for (i = 0; i < A->m; ++i) {
-    /* Dt[i] = 0.; */
-    Dt[i] = b[i] * b[i];
+    Dt[i] = 0.;
+    /* Dt[i] = b[i] * b[i]; */
   }
 
   /* calculate row norms */
@@ -200,15 +205,16 @@ static void compute_l2_mats(ScsMatrix *P, ScsMatrix *A, scs_float *b,
   SCS(enforce_cone_boundaries)(cone, Dt, &SCS(mean));
 
   for (i = 0; i < A->m; ++i) {
-    Dt[i] = SAFEDIV_POS(1.0, SQRTF(apply_limit(Dt[i])));
+    Dt[i] = SQRTF(apply_limit(Dt[i]));
+    Dt[i] = SAFEDIV_POS(1.0, Dt[i]);
   }
 
   /****************************  E  ****************************/
 
   /* initialize E */
   for (i = 0; i < A->n; ++i) {
-    /* Et[i] = 0.; */
-    Et[i] = c[i] * c[i];
+    Et[i] = 0.;
+    /* Et[i] = c[i] * c[i]; */
   }
 
   /* TODO: test not using P to determine scaling  */
@@ -232,19 +238,13 @@ static void compute_l2_mats(ScsMatrix *P, ScsMatrix *A, scs_float *b,
   /* 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]);
-    Et[i] = SAFEDIV_POS(1.0, SQRTF(apply_limit(SQRTF(Et[i]))));
+    Et[i] = SQRTF(apply_limit(SQRTF(Et[i])));
+    Et[i] = SAFEDIV_POS(1.0, Et[i]);
   }
-
-  /* calculate s value */
-  norm_c = SCS(norm_2)(c, A->n);
-  norm_b = SCS(norm_2)(b, A->m);
-  *s = SQRTF(norm_c * norm_c + norm_b * norm_b);
-  *s = SAFEDIV_POS(1.0, SQRTF(apply_limit(*s)));
 }
 
-static void rescale(ScsMatrix *P, ScsMatrix *A, scs_float *b, scs_float *c,
-                    scs_float *Dt, scs_float *Et, scs_float s, ScsScaling *scal,
-                    ScsConeWork *cone) {
+static void rescale(ScsMatrix *P, ScsMatrix *A, scs_float *Dt, scs_float *Et,
+                    ScsScaling *scal, ScsConeWork *cone) {
   scs_int i, j;
   /* scale the rows of A with D */
   for (i = 0; i < A->n; ++i) {
@@ -271,15 +271,6 @@ static void rescale(ScsMatrix *P, ScsMatrix *A, scs_float *b, scs_float *c,
     }
   }
 
-  /* scale c */
-  for (i = 0; i < A->n; ++i) {
-    c[i] *= Et[i];
-  }
-  /* scale b */
-  for (i = 0; i < A->m; ++i) {
-    b[i] *= Dt[i];
-  }
-
   /* Accumulate scaling */
   for (i = 0; i < A->m; ++i) {
     scal->D[i] *= Dt[i];
@@ -288,53 +279,39 @@ static void rescale(ScsMatrix *P, ScsMatrix *A, scs_float *b, scs_float *c,
     scal->E[i] *= Et[i];
   }
 
-  /* Apply scaling */
-  SCS(scale_array)(c, s, A->n);
-  SCS(scale_array)(b, s, A->m);
-  /* no need to scale P since primal_scale = dual_scale */
+  /* no need to scale P since later primal_scale = dual_scale */
   /*
   if (P) {
     SCS(scale_array)(P->x, primal_scale, P->p[P->n]);
     SCS(scale_array)(P->x, 1.0 / dual_scale, P->p[P->n]);
   }
   */
-
-  /* Accumulate scaling */
-  scal->primal_scale *= s;
-  scal->dual_scale *= s;
 }
 
-/* Will rescale as P -> EPE, A -> DAE, c -> sEc, b -> sDb, in-place.
+/* Will rescale as P -> EPE, A -> DAE in-place.
  * Essentially trying to rescale this matrix:
  *
- * [P  A' c]   with   [E  0  0] on both sides (D, E diagonal)
- * [A  0  b]          [0  D  0]
- * [c' b' 0]          [0  0  s]
+ * [P  A']   with   [E  0 ] on both sides (D, E diagonal)
+ * [A  0 ]          [0  D ]
  *
  * which results in:
  *
- * [ EPE   EA'D  sEc ]
- * [ DAE    0    sDb ]
- * [ sc'E  sb'D   0  ]
+ * [ EPE   EA'D ]
+ * [ DAE    0   ]
  *
- * In other words D rescales the rows of A, b
- *                E rescales the cols of A and rows/cols of P, c'
+ * In other words D rescales the rows of A
+ *                E rescales the cols of A and rows/cols of P
  *
- * will repeatedly set: D^-1 ~ norm of rows of [ A  b ]
+ * will repeatedly set: D^-1 ~ norm of rows of [ A ]
  *
  *                      E^-1 ~ norm of cols of [ P ]
  *                                             [ A ]
- *                                             [ c']
- *
- * `s` is incorporated into dual_scale and primal_scale
  *
  * The main complication is that D has to respect cone boundaries.
  *
  */
-ScsScaling *SCS(normalize_a_p)(ScsMatrix *P, ScsMatrix *A, scs_float *b,
-                               scs_float *c, ScsConeWork *cone) {
+ScsScaling *SCS(normalize_a_p)(ScsMatrix *P, ScsMatrix *A, ScsConeWork *cone) {
   scs_int i;
-  scs_float s;
   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));
@@ -359,12 +336,12 @@ ScsScaling *SCS(normalize_a_p)(ScsMatrix *P, ScsMatrix *A, scs_float *b,
   scal->primal_scale = 1.;
   scal->dual_scale = 1.;
   for (i = 0; i < NUM_RUIZ_PASSES; ++i) {
-    compute_ruiz_mats(P, A, b, c, Dt, Et, &s, cone);
-    rescale(P, A, b, c, Dt, Et, s, scal, cone);
+    compute_ruiz_mats(P, A, Dt, Et, cone);
+    rescale(P, A, Dt, Et, scal, cone);
   }
   for (i = 0; i < NUM_L2_PASSES; ++i) {
-    compute_l2_mats(P, A, b, c, Dt, Et, &s, cone);
-    rescale(P, A, b, c, Dt, Et, s, scal, cone);
+    compute_l2_mats(P, A, Dt, Et, cone);
+    rescale(P, A, Dt, Et, scal, cone);
   }
   scs_free(Dt);
   scs_free(Et);
@@ -378,14 +355,13 @@ ScsScaling *SCS(normalize_a_p)(ScsMatrix *P, ScsMatrix *A, scs_float *b,
   }
   scs_printf("primal_scale %g\n", scal->primal_scale);
   scs_printf("dual_scale %g\n", scal->dual_scale);
-  scs_printf("norm_b %g\n", SCS(norm_inf)(b, A->m));
-  scs_printf("norm_c %g\n", SCS(norm_inf)(c, A->n));
   scs_printf("norm D %g\n", SCS(norm_inf)(scal->D, A->m));
   scs_printf("norm E %g\n", SCS(norm_inf)(scal->E, A->n));
 #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;
@@ -411,6 +387,7 @@ void SCS(un_normalize_a_p)(ScsMatrix *A, ScsMatrix *P, const ScsScaling *scal) {
     }
   }
 }
+*/
 
 void SCS(accum_by_atrans)(const ScsMatrix *A, const scs_float *x,
                           scs_float *y) {