scs 0.3.2 → 0.4.1

data/vendor/scs/linsys/scs_matrix.h

@@ -13,11 +13,12 @@ extern "C" {
 /* normalizes A matrix, sets scal->E and scal->D diagonal scaling matrices,
  * A -> D*A*E. D and E must be all positive entries, D must satisfy 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);
 
 /* unnormalizes A matrix, unnormalizes by w->D and w->E */
-void SCS(un_normalize_a_p)(ScsMatrix *A, ScsMatrix *P, const ScsScaling *scal);
+/* void SCS(un_normalize_a_p)(ScsMatrix *A, ScsMatrix *P, const ScsScaling
+ * *scal);
+ */
 
 /* to free the memory allocated in a ScsMatrix (called on A and P at finish) */
 void SCS(free_scs_matrix)(ScsMatrix *A);

data/vendor/scs/scs.mk

@@ -69,6 +69,7 @@ DIRSRC = $(LINSYS)/cpu/direct
 INDIRSRC = $(LINSYS)/cpu/indirect
 GPUDIR = $(LINSYS)/gpu/direct
 GPUINDIR = $(LINSYS)/gpu/indirect
+MKLSRC = $(LINSYS)/mkl/direct
 
 EXTSRC = $(LINSYS)/external
 
@@ -83,48 +84,56 @@ ifeq ($(PREFIX),)
   PREFIX = /usr/local
 endif
 
-OPT_FLAGS =
-########### OPTIONAL FLAGS ##########
+########### CUSTOM FLAGS ##########
 # these can all be override from the command line
+CUSTOM_FLAGS =
 # e.g. make DLONG=1 will override the setting below
 DLONG = 0
 ifneq ($(DLONG), 0)
-OPT_FLAGS += -DDLONG=$(DLONG) # use longs rather than ints
+CUSTOM_FLAGS += -DDLONG=$(DLONG) # use longs rather than ints
 endif
 CTRLC = 1
 ifneq ($(CTRLC), 0)
-OPT_FLAGS += -DCTRLC=$(CTRLC) # graceful interrupts with ctrl-c
+CUSTOM_FLAGS += -DCTRLC=$(CTRLC) # graceful interrupts with ctrl-c
 endif
 SFLOAT = 0
 ifneq ($(SFLOAT), 0)
-OPT_FLAGS += -DSFLOAT=$(SFLOAT) # use floats rather than doubles
-endif
-NOTIMER = 0
-ifneq ($(NOTIMER), 0)
-OPT_FLAGS += -DNOTIMER=$(NOTIMER) # no timing, times reported as nan
-endif
-COPYAMATRIX = 1
-ifneq ($(COPYAMATRIX), 0)
-OPT_FLAGS += -DCOPYAMATRIX=$(COPYAMATRIX) # if normalize, copy A
+CUSTOM_FLAGS += -DSFLOAT=$(SFLOAT) # use floats rather than doubles
 endif
 GPU_TRANSPOSE_MAT = 1
 ifneq ($(GPU_TRANSPOSE_MAT), 0)
-OPT_FLAGS += -DGPU_TRANSPOSE_MAT=$(GPU_TRANSPOSE_MAT) # tranpose A mat in GPU memory
+CUSTOM_FLAGS += -DGPU_TRANSPOSE_MAT=$(GPU_TRANSPOSE_MAT) # transpose A mat in GPU memory
+endif
+NO_TIMER = 0
+ifneq ($(NO_TIMER), 0)
+CUSTOM_FLAGS += -DNO_TIMER=$(NO_TIMER) # no timing, times reported as nan
+endif
+NO_VALIDATE = 0
+ifneq ($(NO_VALIDATE), 0)
+CUSTOM_FLAGS += -DNO_VALIDATE=$(NO_VALIDATE) # perform problem validation or skip
+endif
+NO_PRINTING = 0
+ifneq ($(NO_PRINTING), 0)
+CUSTOM_FLAGS += -DNO_PRINTING=$(NO_PRINTING) # disable printing
 endif
-NOVALIDATE = 0
-ifneq ($(NOVALIDATE), 0)
-OPT_FLAGS += -DNOVALIDATE=$(NOVALIDATE) # perform problem validation or skip
+NO_READ_WRITE = 0
+ifneq ($(NO_READ_WRITE), 0)
+CUSTOM_FLAGS += -DNO_READ_WRITE=$(NO_READ_WRITE) # disable printing
 endif
 ### VERBOSITY LEVELS: 0,1,2,...
 VERBOSITY = 0
 ifneq ($(VERBOSITY), 0)
-OPT_FLAGS += -DVERBOSITY=$(VERBOSITY) # verbosity level
+CUSTOM_FLAGS += -DVERBOSITY=$(VERBOSITY) # verbosity level
 endif
 COVERAGE = 0
 ifneq ($(COVERAGE), 0)
-override CFLAGS += --coverage # generate test coverage data
+CUSTOM_FLAGS += --coverage # generate test coverage data
 endif
 
+# See: https://www.intel.com/content/www/us/en/developer/tools/oneapi/onemkl-link-line-advisor.html
+# This is probably not correct for other systems. TODO: update this
+# to work for all combinations of platform / compiler / threading options.
+MKLFLAGS = -L$(MKLROOT) -L$(MKLROOT)/lib -Wl,--no-as-needed -lmkl_rt -lmkl_gnu_thread -lmkl_core -lgomp -lpthread -ldl
 
 ############ OPENMP: ############
 # set USE_OPENMP = 1 to allow openmp (multi-threaded matrix multiplies):
@@ -142,44 +151,44 @@ endif
 # NB: point the libraries to the locations where
 # you have blas and lapack installed
 
+BLASLDFLAGS =
 USE_LAPACK = 1
 ifneq ($(USE_LAPACK), 0)
   # edit these for your setup:
-  BLASLDFLAGS = -llapack -lblas # -lgfortran
-  LDFLAGS += $(BLASLDFLAGS)
-  OPT_FLAGS += -DUSE_LAPACK
+  BLASLDFLAGS += -llapack -lblas # -lgfortran
+  CUSTOM_FLAGS += -DUSE_LAPACK
 
   BLAS64 = 0
   ifneq ($(BLAS64), 0)
-  OPT_FLAGS += -DBLAS64=$(BLAS64) # if blas/lapack lib uses 64 bit ints
+  CUSTOM_FLAGS += -DBLAS64=$(BLAS64) # if blas/lapack lib uses 64 bit ints
   endif
 
   NOBLASSUFFIX = 0
   ifneq ($(NOBLASSUFFIX), 0)
-  OPT_FLAGS += -DNOBLASSUFFIX=$(NOBLASSUFFIX) # hack to strip blas suffix
+  CUSTOM_FLAGS += -DNOBLASSUFFIX=$(NOBLASSUFFIX) # hack to strip blas suffix
   endif
 
   BLASSUFFIX = "_"
   ifneq ($(BLASSUFFIX), "_")
-  OPT_FLAGS += -DBLASSUFFIX=$(BLASSUFFIX) # blas suffix (underscore usually)
+  CUSTOM_FLAGS += -DBLASSUFFIX=$(BLASSUFFIX) # blas suffix (underscore usually)
   endif
 endif
 
 MATLAB_MEX_FILE = 0
 ifneq ($(MATLAB_MEX_FILE), 0)
-OPT_FLAGS += -DMATLAB_MEX_FILE=$(MATLAB_MEX_FILE) # matlab mex
+CUSTOM_FLAGS += -DMATLAB_MEX_FILE=$(MATLAB_MEX_FILE) # matlab mex
 endif
 PYTHON = 0
 ifneq ($(PYTHON), 0)
-OPT_FLAGS += -DPYTHON=$(PYTHON) # python extension
+CUSTOM_FLAGS += -DPYTHON=$(PYTHON) # python extension
 endif
 USING_R = 0
 ifneq ($(USING_R), 0)
-OPT_FLAGS += -DUSING_R=$(USING_R) # R extension
+CUSTOM_FLAGS += -DUSING_R=$(USING_R) # R extension
 endif
 
 # debug to see var values, e.g. 'make print-OBJECTS' shows OBJECTS value
 print-%: ; @echo $*=$($*)
 
-override CFLAGS += $(OPT_FLAGS)
-CUDAFLAGS += $(OPT_FLAGS)
+override CFLAGS += $(CUSTOM_FLAGS)
+CUDAFLAGS += $(CUSTOM_FLAGS)

data/vendor/scs/src/aa.c

@@ -199,7 +199,6 @@ static void set_m(AaWork *a, aa_int len) {
     }
   }
   TIME_TOC
-  return;
 }
 
 /* initialize accel params, in particular x_prev, f_prev, g_prev */
@@ -278,7 +277,6 @@ static void update_accel_params(const aa_float *x, const aa_float *f, AaWork *a,
   a->norm_g = BLAS(nrm2)(&bdim, a->g, &one);
 
   TIME_TOC
-  return;
 }
 
 /* f = (1-relaxation) * \sum_i a_i x_i + relaxation * \sum_i a_i f_i */
@@ -493,7 +491,6 @@ void aa_finish(AaWork *a) {
     }
     free(a);
   }
-  return;
 }
 
 void aa_reset(AaWork *a) {
@@ -502,7 +499,6 @@ void aa_reset(AaWork *a) {
     printf("AA reset.\n");
   }
   a->iter = 0;
-  return;
 }
 
 #endif

data/vendor/scs/src/cones.c

@@ -4,10 +4,8 @@
 #include "scs_blas.h" /* contains BLAS(X) macros and type info */
 #include "util.h"
 
-#define CONE_TOL (1e-9)
-#define CONE_THRESH (1e-8)
-#define EXP_CONE_MAX_ITERS (100)
 #define BOX_CONE_MAX_ITERS (25)
+#define POW_CONE_TOL (1e-9)
 #define POW_CONE_MAX_ITERS (20)
 
 /* Box cone limits (+ or -) taken to be INF */
@@ -35,6 +33,62 @@ void BLAS(scal)(const blas_int *n, const scs_float *sa, scs_float *sx,
 
 #endif
 
+/* Forward declare exponential cone projection routine.
+ * Implemented in exp_cone.c.
+ */
+scs_float SCS(proj_pd_exp_cone)(scs_float *v0, scs_int primal);
+
+void SCS(free_cone)(ScsCone *k) {
+  if (k) {
+    if (k->bu)
+      scs_free(k->bu);
+    if (k->bl)
+      scs_free(k->bl);
+    if (k->q)
+      scs_free(k->q);
+    if (k->s)
+      scs_free(k->s);
+    if (k->p)
+      scs_free(k->p);
+    scs_free(k);
+  }
+}
+
+void SCS(deep_copy_cone)(ScsCone *dest, const ScsCone *src) {
+  memcpy(dest, src, sizeof(ScsCone));
+  /* copy bu, bl */
+  if (src->bsize > 1) {
+    dest->bu = (scs_float *)scs_calloc(src->bsize - 1, sizeof(scs_float));
+    memcpy(dest->bu, src->bu, (src->bsize - 1) * sizeof(scs_float));
+    dest->bl = (scs_float *)scs_calloc(src->bsize - 1, sizeof(scs_float));
+    memcpy(dest->bl, src->bl, (src->bsize - 1) * sizeof(scs_float));
+  } else {
+    dest->bu = SCS_NULL;
+    dest->bl = SCS_NULL;
+  }
+  /* copy SOC */
+  if (src->qsize > 0) {
+    dest->q = (scs_int *)scs_calloc(src->qsize, sizeof(scs_int));
+    memcpy(dest->q, src->q, src->qsize * sizeof(scs_int));
+  } else {
+    dest->q = SCS_NULL;
+  }
+  /* copy PSD cone */
+  if (src->ssize > 0) {
+    dest->s = (scs_int *)scs_calloc(src->ssize, sizeof(scs_int));
+    memcpy(dest->s, src->s, src->ssize * sizeof(scs_int));
+  } else {
+    dest->s = SCS_NULL;
+  }
+  /* copy power cone */
+  if (src->psize > 0) {
+    dest->p = (scs_float *)scs_calloc(src->psize, sizeof(scs_float));
+    memcpy(dest->p, src->p, src->psize * sizeof(scs_float));
+  } else {
+    dest->p = SCS_NULL;
+  }
+}
+
 /* set the vector of rho y terms, based on scale and cones */
 void SCS(set_r_y)(const ScsConeWork *c, scs_float scale, scs_float *r_y) {
   scs_int i;
@@ -228,19 +282,13 @@ void SCS(finish_cone)(ScsConeWork *c) {
   if (c->s) {
     scs_free(c->s);
   }
-  if (c->bu) {
-    scs_free(c->bu);
-  }
-  if (c->bl) {
-    scs_free(c->bl);
-  }
   if (c) {
     scs_free(c);
   }
 }
 
 char *SCS(get_cone_header)(const ScsCone *k) {
-  char *tmp = (char *)scs_malloc(sizeof(char) * 512);
+  char *tmp = (char *)scs_malloc(512); /* sizeof(char) = 1 */
   scs_int i, soc_vars, sd_vars;
   sprintf(tmp, "cones: ");
   if (k->z) {
@@ -280,118 +328,6 @@ char *SCS(get_cone_header)(const ScsCone *k) {
   return tmp;
 }
 
-static scs_float exp_newton_one_d(scs_float rho, scs_float y_hat,
-                                  scs_float z_hat, scs_float w) {
-  scs_float t_prev, t = MAX(w - z_hat, MAX(-z_hat, 1e-9));
-  scs_float f = 1., fp = 1.;
-  scs_int i;
-  for (i = 0; i < EXP_CONE_MAX_ITERS; ++i) {
-    t_prev = t;
-    f = t * (t + z_hat) / rho / rho - y_hat / rho + log(t / rho) + 1;
-    fp = (2 * t + z_hat) / rho / rho + 1 / t;
-
-    t = t - f / fp;
-
-    if (t <= -z_hat) {
-      t = -z_hat;
-      break;
-    } else if (t <= 0) {
-      t = 0;
-      break;
-    } else if (ABS(t - t_prev) < CONE_TOL) {
-      break;
-    } else if (SQRTF(f * f / fp) < CONE_TOL) {
-      break;
-    }
-  }
-  if (i == EXP_CONE_MAX_ITERS) {
-    scs_printf("warning: exp cone newton step hit maximum %i iters\n", (int)i);
-    scs_printf("rho=%1.5e; y_hat=%1.5e; z_hat=%1.5e; w=%1.5e; f=%1.5e, "
-               "fp=%1.5e, t=%1.5e, t_prev= %1.5e\n",
-               rho, y_hat, z_hat, w, f, fp, t, t_prev);
-  }
-  return t + z_hat;
-}
-
-static void exp_solve_for_x_with_rho(const scs_float *v, scs_float *x,
-                                     scs_float rho, scs_float w) {
-  x[2] = exp_newton_one_d(rho, v[1], v[2], w);
-  x[1] = (x[2] - v[2]) * x[2] / rho;
-  x[0] = v[0] - rho;
-}
-
-static scs_float exp_calc_grad(const scs_float *v, scs_float *x, scs_float rho,
-                               scs_float w) {
-  exp_solve_for_x_with_rho(v, x, rho, w);
-  if (x[1] <= 1e-12) {
-    return x[0];
-  }
-  return x[0] + x[1] * log(x[1] / x[2]);
-}
-
-static void exp_get_rho_ub(const scs_float *v, scs_float *x, scs_float *ub,
-                           scs_float *lb) {
-  *lb = 0;
-  *ub = 0.125;
-  while (exp_calc_grad(v, x, *ub, v[1]) > 0) {
-    *lb = *ub;
-    (*ub) *= 2;
-  }
-}
-
-/* project onto the exponential cone, v has dimension *exactly* 3 */
-static scs_int proj_exp_cone(scs_float *v) {
-  scs_int i;
-  scs_float ub, lb, rho, g, x[3];
-  scs_float r = v[0], s = v[1], t = v[2];
-
-  /* v in cl(Kexp) */
-  if ((s * exp(r / s) - t <= CONE_THRESH && s > 0) ||
-      (r <= 0 && s == 0 && t >= 0)) {
-    return 0;
-  }
-
-  /* -v in Kexp^* */
-  if ((r > 0 && r * exp(s / r) + exp(1) * t <= CONE_THRESH) ||
-      (r == 0 && s <= 0 && t <= 0)) {
-    memset(v, 0, 3 * sizeof(scs_float));
-    return 0;
-  }
-
-  /* special case with analytical solution */
-  if (r < 0 && s < 0) {
-    v[1] = 0.0;
-    v[2] = MAX(v[2], 0);
-    return 0;
-  }
-
-  /* iterative procedure to find projection, bisects on dual variable: */
-  exp_get_rho_ub(v, x, &ub, &lb); /* get starting upper and lower bounds */
-  for (i = 0; i < EXP_CONE_MAX_ITERS; ++i) {
-    rho = (ub + lb) / 2; /* halfway between upper and lower bounds */
-    g = exp_calc_grad(v, x, rho, x[1]); /* calculates gradient wrt dual var */
-    if (g > 0) {
-      lb = rho;
-    } else {
-      ub = rho;
-    }
-    if (ub - lb < CONE_TOL) {
-      break;
-    }
-  }
-#if VERBOSITY > 10
-  scs_printf("exponential cone proj iters %i\n", (int)i);
-#endif
-  if (i == EXP_CONE_MAX_ITERS) {
-    scs_printf("warning: exp cone outer step hit maximum %i iters\n", (int)i);
-    scs_printf("r=%1.5e; s=%1.5e; t=%1.5e\n", r, s, t);
-  }
-  v[0] = x[0];
-  v[1] = x[1];
-  v[2] = x[2];
-  return 0;
-}
-
 static scs_int set_up_sd_cone_work_space(ScsConeWork *c, const ScsCone *k) {
   scs_int i;
 #ifdef USE_LAPACK
@@ -580,18 +516,18 @@ static scs_float pow_calc_fp(scs_float x, scs_float y, scs_float dxdr,
  *       { (t', s') | t' * l' <= s' <= t' u', t >= 0 } = K'
  *  where l' = D l  / d0, u' = D u / d0.
  */
-static void normalize_box_cone(ScsConeWork *c, scs_float *D, scs_int bsize) {
+static void normalize_box_cone(ScsCone *k, scs_float *D, scs_int bsize) {
   scs_int j;
   for (j = 0; j < bsize - 1; j++) {
-    if (c->bu[j] >= MAX_BOX_VAL) {
-      c->bu[j] = INFINITY;
+    if (k->bu[j] >= MAX_BOX_VAL) {
+      k->bu[j] = INFINITY;
     } else {
-      c->bu[j] = D ? D[j + 1] * c->bu[j] / D[0] : c->bu[j];
+      k->bu[j] = D ? D[j + 1] * k->bu[j] / D[0] : k->bu[j];
     }
-    if (c->bl[j] <= -MAX_BOX_VAL) {
-      c->bl[j] = -INFINITY;
+    if (k->bl[j] <= -MAX_BOX_VAL) {
+      k->bl[j] = -INFINITY;
     } else {
-      c->bl[j] = D ? D[j + 1] * c->bl[j] / D[0] : c->bl[j];
+      k->bl[j] = D ? D[j + 1] * k->bl[j] / D[0] : k->bl[j];
     }
   }
 }
@@ -696,13 +632,13 @@ static void proj_power_cone(scs_float *v, scs_float a) {
   scs_int i;
   /* v in K_a */
   if (xh >= 0 && yh >= 0 &&
-      CONE_THRESH + POWF(xh, a) * POWF(yh, (1 - a)) >= rh) {
+      POW_CONE_TOL + POWF(xh, a) * POWF(yh, (1 - a)) >= rh) {
     return;
   }
 
   /* -v in K_a^* */
   if (xh <= 0 && yh <= 0 &&
-      CONE_THRESH + POWF(-xh, a) * POWF(-yh, 1 - a) >=
+      POW_CONE_TOL + POWF(-xh, a) * POWF(-yh, 1 - a) >=
           rh * POWF(a, a) * POWF(1 - a, 1 - a)) {
     v[0] = v[1] = v[2] = 0;
     return;
@@ -715,7 +651,7 @@ static void proj_power_cone(scs_float *v, scs_float a) {
     y = pow_calc_x(r, yh, rh, 1 - a);
 
     f = pow_calc_f(x, y, r, a);
-    if (ABS(f) < CONE_TOL) {
+    if (ABS(f) < POW_CONE_TOL) {
       break;
     }
 
@@ -740,7 +676,6 @@ static scs_int proj_cone(scs_float *x, const ScsCone *k, ScsConeWork *c,
   scs_int i, status;
   scs_int count = 0;
   scs_float *r_box = SCS_NULL;
-  scs_float *bu, *bl;
 
   if (k->z) { /* doesn't use r_y */
     /* project onto primal zero / dual free cone */
@@ -761,9 +696,7 @@ static scs_int proj_cone(scs_float *x, const ScsCone *k, ScsConeWork *c,
       r_box = &(r_y[count]);
     }
     /* project onto box cone */
-    bu = normalize ? c->bu : k->bu;
-    bl = normalize ? c->bl : k->bl;
-    c->box_t_warm_start = proj_box_cone(&(x[count]), bl, bu, k->bsize,
+    c->box_t_warm_start = proj_box_cone(&(x[count]), k->bl, k->bu, k->bsize,
                                         c->box_t_warm_start, r_box);
     count += k->bsize; /* since b = (t,s), len(s) = bsize - 1 */
   }
@@ -787,51 +720,16 @@ static scs_int proj_cone(scs_float *x, const ScsCone *k, ScsConeWork *c,
     }
   }
 
-  if (k->ep) { /* doesn't use r_y */
-               /*
-                * exponential cone is not self dual, if s \in K
-                * then y \in K^* and so if K is the primal cone
-                * here we project onto K^*, via Moreau
-                * \Pi_C^*(y) = y + \Pi_C(-y)
-                */
+  if (k->ep || k->ed) { /* doesn't use r_y */
 #ifdef _OPENMP
 #pragma omp parallel for
 #endif
-    for (i = 0; i < k->ep; ++i) {
-      proj_exp_cone(&(x[count + 3 * i]));
+    for (i = 0; i < k->ep + k->ed; ++i) {
+      /* provided in exp_cone.c */
+      SCS(proj_pd_exp_cone)(&(x[count + 3 * i]), i < k->ep);
     }
-    count += 3 * k->ep;
+    count += 3 * (k->ep + k->ed);
   }
-
-  /* dual exponential cone */
-  if (k->ed) { /* doesn't use r_y */
-    /*
-     * exponential cone is not self dual, if s \in K
-     * then y \in K^* and so if K is the primal cone
-     * here we project onto K^*, via Moreau
-     * \Pi_C^*(y) = y + \Pi_C(-y)
-     */
-    scs_int idx;
-    scs_float r, s, t;
-    SCS(scale_array)(&(x[count]), -1, 3 * k->ed); /* x = -x; */
-#ifdef _OPENMP
-#pragma omp parallel for private(r, s, t, idx)
-#endif
-    for (i = 0; i < k->ed; ++i) {
-      idx = count + 3 * i;
-      r = x[idx];
-      s = x[idx + 1];
-      t = x[idx + 2];
-
-      proj_exp_cone(&(x[idx]));
-
-      x[idx] -= r;
-      x[idx + 1] -= s;
-      x[idx + 2] -= t;
-    }
-    count += 3 * k->ed;
-  }
-
   if (k->psize && k->p) { /* doesn't use r_y */
     scs_float v[3];
     scs_int idx;
@@ -864,7 +762,7 @@ static scs_int proj_cone(scs_float *x, const ScsCone *k, ScsConeWork *c,
   return 0;
 }
 
-ScsConeWork *SCS(init_cone)(const ScsCone *k, scs_int m) {
+ScsConeWork *SCS(init_cone)(ScsCone *k, scs_int m) {
   ScsConeWork *c = (ScsConeWork *)scs_calloc(1, sizeof(ScsConeWork));
   c->k = k;
   c->m = m;
@@ -880,16 +778,12 @@ ScsConeWork *SCS(init_cone)(const ScsCone *k, scs_int m) {
   return c;
 }
 
-void scale_box_cone(const ScsCone *k, ScsConeWork *c, ScsScaling *scal) {
+void scale_box_cone(ScsCone *k, ScsConeWork *c, ScsScaling *scal) {
   if (k->bsize && k->bu && k->bl) {
     c->box_t_warm_start = 1.;
     if (scal) {
-      c->bu = (scs_float *)scs_calloc(k->bsize - 1, sizeof(scs_float));
-      c->bl = (scs_float *)scs_calloc(k->bsize - 1, sizeof(scs_float));
-      memcpy(c->bu, k->bu, (k->bsize - 1) * sizeof(scs_float));
-      memcpy(c->bl, k->bl, (k->bsize - 1) * sizeof(scs_float));
       /* also does some sanitizing */
-      normalize_box_cone(c, &(scal->D[k->z + k->l]), k->bsize);
+      normalize_box_cone(k, &(scal->D[k->z + k->l]), k->bsize);
     }
   }
 }
@@ -909,7 +803,7 @@ void scale_box_cone(const ScsCone *k, ScsConeWork *c, ScsScaling *scal) {
 scs_int SCS(proj_dual_cone)(scs_float *x, ScsConeWork *c, ScsScaling *scal,
                             scs_float *r_y) {
   scs_int status, i;
-  const ScsCone *k = c->k;
+  ScsCone *k = c->k;
 
   if (!c->scaled_cones) {
     scale_box_cone(k, c, scal);