scs 0.2.2

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

@@ -0,0 +1,36 @@
+#ifndef PRIV_H_GUARD
+#define PRIV_H_GUARD
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "gpu.h"
+#include "glbopts.h"
+#include "linalg.h"
+#include "scs.h"
+
+
+struct SCS_LIN_SYS_WORK {
+  /* reporting */
+  scs_int tot_cg_its;
+  scs_float total_solve_time;
+  /* ALL BELOW HOSTED ON THE GPU */
+  scs_float *p;     /* cg iterate, n  */
+  scs_float *r;     /* cg residual, n */
+  scs_float *Gp;    /* G * p, n */
+  scs_float *bg;    /* b, n */
+  scs_float *tmp_m; /* m, used in mat_vec */
+  scs_float *z;     /* preconditioned */
+  scs_float *M;     /* preconditioner */
+  ScsGpuMatrix *Ag;    /* A matrix on GPU */
+  ScsGpuMatrix *Agt;   /* A trans matrix on GPU */
+  /* CUDA */
+  cublasHandle_t cublas_handle;
+  cusparseHandle_t cusparse_handle;
+};
+
+#ifdef __cplusplus
+}
+#endif
+#endif

data/vendor/scs/scs.mk

@@ -0,0 +1,181 @@
+ifeq ($(OS),Windows_NT)
+UNAME = CYGWINorMINGWorMSYS
+else
+UNAME = $(shell uname -s)
+endif
+
+#CC = gcc
+# For cross-compiling with mingw use these.
+#CC = i686-w64-mingw32-gcc -m32
+#CC = x86_64-w64-mingw32-gcc-4.8
+CUCC = $(CC) #Don't need to use nvcc, since using cuda blas APIs
+
+# For GPU must add cuda libs to path, e.g.
+# export DYLD_LIBRARY_PATH=/usr/local/cuda/lib:$DYLD_LIBRARY_PATH
+
+ifneq (, $(findstring CYGWIN, $(UNAME)))
+ISWINDOWS := 1
+else
+ifneq (, $(findstring MINGW, $(UNAME)))
+ISWINDOWS := 1
+else
+ifneq (, $(findstring MSYS, $(UNAME)))
+ISWINDOWS := 1
+else
+ifneq (, $(findstring mingw, $(CC)))
+ISWINDOWS := 1
+else
+ISWINDOWS := 0
+endif
+endif
+endif
+endif
+
+ifeq ($(UNAME), Darwin)
+# we're on apple, no need to link rt library
+LDFLAGS += -lm
+SHARED = dylib
+SONAME = -install_name
+else
+ifeq ($(ISWINDOWS), 1)
+# we're on windows (cygwin or msys)
+LDFLAGS += -lm
+SHARED = dll
+SONAME = -soname
+else
+# we're on a linux system, use accurate timer provided by clock_gettime()
+LDFLAGS += -lm -lrt
+SHARED = so
+SONAME = -soname
+endif
+endif
+
+#TODO: check if this works for all platforms:
+ifeq ($(CUDA_PATH), )
+CUDA_PATH=/usr/local/cuda
+endif
+CULDFLAGS = -L$(CUDA_PATH)/lib -L$(CUDA_PATH)/lib64 -lcudart -lcublas -lcusparse
+CUDAFLAGS = $(CFLAGS) -I$(CUDA_PATH)/include -Ilinsys/gpu -Wno-c++11-long-long # turn off annoying long-long warnings in cuda header files
+
+# Add on default CFLAGS
+OPT = -O3
+override CFLAGS += -g -Wall -Wwrite-strings -pedantic -funroll-loops -Wstrict-prototypes -I. -Iinclude -Ilinsys $(OPT)
+ifneq ($(ISWINDOWS), 1)
+override CFLAGS += -fPIC
+endif
+
+LINSYS = linsys
+DIRSRC = $(LINSYS)/cpu/direct
+INDIRSRC = $(LINSYS)/cpu/indirect
+GPUDIR = $(LINSYS)/gpu/direct
+GPUINDIR = $(LINSYS)/gpu/indirect
+
+EXTSRC = $(LINSYS)/external
+
+OUT = out
+AR = ar
+ARFLAGS = rv
+ARCHIVE = $(AR) $(ARFLAGS)
+RANLIB = ranlib
+INSTALL = install
+
+ifeq ($(PREFIX),)
+  PREFIX = /usr/local
+endif
+
+OPT_FLAGS =
+########### OPTIONAL FLAGS ##########
+# these can all be override from the command line
+# e.g. make DLONG=1 will override the setting below
+DLONG = 0
+ifneq ($(DLONG), 0)
+OPT_FLAGS += -DDLONG=$(DLONG) # use longs rather than ints
+endif
+CTRLC = 1
+ifneq ($(CTRLC), 0)
+OPT_FLAGS += -DCTRLC=$(CTRLC) # graceful interrupts with ctrl-c
+endif
+SFLOAT = 0
+ifneq ($(SFLOAT), 0)
+OPT_FLAGS += -DSFLOAT=$(SFLOAT) # use floats rather than doubles
+endif
+NOVALIDATE = 0
+ifneq ($(NOVALIDATE), 0)
+OPT_FLAGS += -DNOVALIDATE=$(NOVALIDATE)$ # remove data validation step
+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
+endif
+GPU_TRANSPOSE_MAT = 1
+ifneq ($(GPU_TRANSPOSE_MAT), 0)
+OPT_FLAGS += -DGPU_TRANSPOSE_MAT=$(GPU_TRANSPOSE_MAT) # tranpose A mat in GPU memory
+endif
+
+### VERBOSITY LEVELS: 0,1,2
+EXTRA_VERBOSE = 0
+ifneq ($(EXTRA_VERBOSE), 0)
+OPT_FLAGS += -DEXTRA_VERBOSE=$(EXTRA_VERBOSE) # extra verbosity level
+endif
+
+############ OPENMP: ############
+# set USE_OPENMP = 1 to allow openmp (multi-threaded matrix multiplies):
+# set the number of threads to, for example, 4 by entering the command:
+# export OMP_NUM_THREADS=4
+
+USE_OPENMP = 0
+ifneq ($(USE_OPENMP), 0)
+  override CFLAGS += -fopenmp
+  LDFLAGS += -lgomp
+endif
+
+############ SDPS: BLAS + LAPACK ############
+# set USE_LAPACK = 1 below to enable solving SDPs
+# NB: point the libraries to the locations where
+# you have blas and lapack installed
+
+USE_LAPACK = 1
+ifneq ($(USE_LAPACK), 0)
+  # edit these for your setup:
+  BLASLDFLAGS = -lblas -llapack #-lgfortran
+  LDFLAGS += $(BLASLDFLAGS)
+  OPT_FLAGS += -DUSE_LAPACK
+
+  BLAS64 = 0
+  ifneq ($(BLAS64), 0)
+  OPT_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
+  endif
+
+  BLASSUFFIX = "_"
+  ifneq ($(BLASSUFFIX), "_")
+  OPT_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
+endif
+PYTHON = 0
+ifneq ($(PYTHON), 0)
+OPT_FLAGS += -DPYTHON=$(PYTHON) # python extension
+endif
+USING_R = 0
+ifneq ($(USING_R), 0)
+OPT_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)

data/vendor/scs/src/aa.c

@@ -0,0 +1,224 @@
+#include "aa.h"
+#include "scs_blas.h"
+
+/* This file uses Anderson acceleration to improve the convergence of
+ * a fixed point mapping.
+ * At each iteration we need to solve a (small) linear system, we
+ * do this using LAPACK ?gesv.
+ */
+
+#ifndef USE_LAPACK
+
+typedef void * ACCEL_WORK;
+
+AaWork *aa_init(aa_int dim, aa_int aa_mem, aa_int type1) { return SCS_NULL; }
+aa_int aa_apply(aa_float *f, const aa_float *x, AaWork *a) { return 0; }
+void aa_finish(AaWork *a) {}
+
+#else
+
+/* contains the necessary parameters to perform aa at each step */
+struct ACCEL_WORK {
+  aa_int type1; /* bool, if true type 1 aa otherwise type 2 */
+  aa_int k;     /* aa memory */
+  aa_int l;     /* variable dimension */
+  aa_int iter;  /* current iteration */
+
+  aa_float *x; /* x input to map*/
+  aa_float *f; /* f(x) output of map */
+  aa_float *g; /* x - f(x) */
+
+  /* from previous iteration */
+  aa_float *g_prev; /* x - f(x) */
+
+  aa_float *y; /* g - g_prev */
+  aa_float *s; /* x - x_prev */
+  aa_float *d; /* f - f_prev */
+
+  aa_float *Y; /* matrix of stacked y values */
+  aa_float *S; /* matrix of stacked s values */
+  aa_float *D; /* matrix of stacked d values = (S-Y) */
+  aa_float *M; /* S'Y or Y'Y depending on type of aa */
+
+  /* workspace variables */
+  aa_float *work;
+  blas_int *ipiv;
+};
+
+/* BLAS functions used */
+aa_float BLAS(nrm2)(blas_int *n, aa_float *x, blas_int *incx);
+void BLAS(axpy)(blas_int *n, aa_float *a, const aa_float *x, blas_int *incx,
+                aa_float *y, blas_int *incy);
+void BLAS(gemv)(const char *trans, const blas_int *m, const blas_int *n,
+                const aa_float *alpha, const aa_float *a, const blas_int *lda,
+                const aa_float *x, const blas_int *incx, const aa_float *beta,
+                aa_float *y, const blas_int *incy);
+void BLAS(gesv)(blas_int *n, blas_int *nrhs, aa_float *a, blas_int *lda,
+                blas_int *ipiv, aa_float *b, blas_int *ldb, blas_int *info);
+void BLAS(gemm)(const char *transa, const char *transb, blas_int *m,
+                blas_int *n, blas_int *k, aa_float *alpha, aa_float *a,
+                blas_int *lda, aa_float *b, blas_int *ldb, aa_float *beta,
+                aa_float *c, blas_int *ldc);
+
+/* sets a->M to S'Y or Y'Y depending on type of aa used */
+static void set_m(AaWork *a) {
+  blas_int bl = (blas_int)(a->l), bk = (blas_int)a->k;
+  aa_float onef = 1.0, zerof = 0.0;
+  BLAS(gemm)
+  ("Trans", "No", &bk, &bk, &bl, &onef, a->type1 ? a->S : a->Y, &bl, a->Y, &bl,
+   &zerof, a->M, &bk);
+}
+
+/* updates the workspace parameters for aa for this iteration */
+static void update_accel_params(const aa_float *x, const aa_float *f,
+                                AaWork *a) {
+  /* at the start a->x = x_prev and a->f = f_prev */
+  aa_int idx = a->iter % a->k;
+  aa_int l = a->l;
+
+  blas_int one = 1;
+  blas_int bl = (blas_int)l;
+  aa_float neg_onef = -1.0;
+
+  /* g = x */
+  memcpy(a->g, x, sizeof(aa_float) * l);
+  /* s = x */
+  memcpy(a->s, x, sizeof(aa_float) * l);
+  /* d = f */
+  memcpy(a->d, f, sizeof(aa_float) * l);
+  /* g -= f */
+  BLAS(axpy)(&bl, &neg_onef, f, &one, a->g, &one);
+  /* s -= x_prev */
+  BLAS(axpy)(&bl, &neg_onef, a->x, &one, a->s, &one);
+  /* d -= f_prev */
+  BLAS(axpy)(&bl, &neg_onef, a->f, &one, a->d, &one);
+
+  /* g, s, d correct here */
+
+  /* y = g */
+  memcpy(a->y, a->g, sizeof(aa_float) * l);
+  /* y -= g_prev */
+  BLAS(axpy)(&bl, &neg_onef, a->g_prev, &one, a->y, &one);
+
+  /* y correct here */
+
+  /* copy y into idx col of Y */
+  memcpy(&(a->Y[idx * l]), a->y, sizeof(aa_float) * l);
+  /* copy s into idx col of S */
+  memcpy(&(a->S[idx * l]), a->s, sizeof(aa_float) * l);
+  /* copy d into idx col of D */
+  memcpy(&(a->D[idx * l]), a->d, sizeof(aa_float) * l);
+
+  /* Y, S,D correct here */
+
+  memcpy(a->f, f, sizeof(aa_float) * l);
+  memcpy(a->x, x, sizeof(aa_float) * l);
+
+  /* x, f correct here */
+
+  /* set M = S'*Y */
+  set_m(a);
+
+  /* M correct here */
+
+  memcpy(a->g_prev, a->g, sizeof(aa_float) * l);
+
+  /* g_prev set for next iter here */
+}
+
+/* solves the system of equations to perform the aa update
+ * at the end f contains the next iterate to be returned
+ */
+static aa_int solve(aa_float *f, AaWork *a, aa_int len) {
+  blas_int info = -1, bl = (blas_int)(a->l), one = 1, blen = (blas_int)len,
+           bk = (blas_int)a->k;
+  aa_float neg_onef = -1.0, onef = 1.0, zerof = 0.0, nrm;
+  /* work = S'g or Y'g */
+  BLAS(gemv)
+  ("Trans", &bl, &blen, &onef, a->type1 ? a->S : a->Y, &bl, a->g, &one, &zerof,
+   a->work, &one);
+  /* work = M \ work, where M = S'Y or M = Y'Y */
+  BLAS(gesv)(&blen, &one, a->M, &bk, a->ipiv, a->work, &blen, &info);
+  nrm = BLAS(nrm2)(&bk, a->work, &one);
+  if (info < 0 || nrm >= MAX_AA_NRM) {
+    #if EXTRA_VERBOSE > 0
+    scs_printf("Error in AA type %i, iter: %i, info: %i, norm %1.2e\n",
+           a->type1 ? 1 : 2, (int)a->iter, (int)info, nrm);
+    #endif
+    return -1;
+  }
+  /* if solve was successful then set f -= D * work */
+  BLAS(gemv)
+  ("NoTrans", &bl, &blen, &neg_onef, a->D, &bl, a->work, &one, &onef, f, &one);
+  return (aa_int)info;
+}
+
+/*
+ * API functions below this line, see aa.h for descriptions.
+ */
+AaWork *aa_init(aa_int l, aa_int aa_mem, aa_int type1) {
+  AaWork *a = (AaWork *)calloc(1, sizeof(AaWork));
+  if (!a) {
+    scs_printf("Failed to allocate memory for AA.\n");
+    return (void *)0;
+  }
+  a->type1 = type1;
+  a->iter = 0;
+  a->l = l;
+  a->k = aa_mem;
+  if (a->k <= 0) {
+    return a;
+  }
+
+  a->x = (aa_float *)calloc(a->l, sizeof(aa_float));
+  a->f = (aa_float *)calloc(a->l, sizeof(aa_float));
+  a->g = (aa_float *)calloc(a->l, sizeof(aa_float));
+
+  a->g_prev = (aa_float *)calloc(a->l, sizeof(aa_float));
+
+  a->y = (aa_float *)calloc(a->l, sizeof(aa_float));
+  a->s = (aa_float *)calloc(a->l, sizeof(aa_float));
+  a->d = (aa_float *)calloc(a->l, sizeof(aa_float));
+
+  a->Y = (aa_float *)calloc(a->l * a->k, sizeof(aa_float));
+  a->S = (aa_float *)calloc(a->l * a->k, sizeof(aa_float));
+  a->D = (aa_float *)calloc(a->l * a->k, sizeof(aa_float));
+
+  a->M = (aa_float *)calloc(a->k * a->k, sizeof(aa_float));
+  a->work = (aa_float *)calloc(a->k, sizeof(aa_float));
+  a->ipiv = (blas_int *)calloc(a->k, sizeof(blas_int));
+  return a;
+}
+
+aa_int aa_apply(aa_float *f, const aa_float *x, AaWork *a) {
+  if (a->k <= 0) {
+    return 0;
+  }
+  update_accel_params(x, f, a);
+  if (a->iter++ == 0) {
+    return 0;
+  }
+  /* solve linear system, new point overwrites f if successful */
+  return solve(f, a, MIN(a->iter - 1, a->k));
+}
+
+void aa_finish(AaWork *a) {
+  if (a) {
+    free(a->x);
+    free(a->f);
+    free(a->g);
+    free(a->g_prev);
+    free(a->y);
+    free(a->s);
+    free(a->d);
+    free(a->Y);
+    free(a->S);
+    free(a->D);
+    free(a->M);
+    free(a->work);
+    free(a->ipiv);
+    free(a);
+  }
+}
+
+#endif

data/vendor/scs/src/cones.c

@@ -0,0 +1,802 @@
+#include "cones.h"
+
+#include "linalg.h"
+#include "scs.h"
+#include "scs_blas.h" /* contains BLAS(X) macros and type info */
+#include "util.h"
+
+#define CONE_RATE (2)
+#define CONE_TOL (1e-8)
+#define CONE_THRESH (1e-6)
+#define EXP_CONE_MAX_ITERS (100)
+#define POW_CONE_MAX_ITERS (20)
+
+#ifdef USE_LAPACK
+void BLAS(syevr)(const char *jobz, const char *range, const char *uplo,
+                 blas_int *n, scs_float *a, blas_int *lda, scs_float *vl,
+                 scs_float *vu, blas_int *il, blas_int *iu, scs_float *abstol,
+                 blas_int *m, scs_float *w, scs_float *z, blas_int *ldz,
+                 blas_int *isuppz, scs_float *work, blas_int *lwork,
+                 blas_int *iwork, blas_int *liwork, blas_int *info);
+void BLAS(syr)(const char *uplo, const blas_int *n, const scs_float *alpha,
+               const scs_float *x, const blas_int *incx, scs_float *a,
+               const blas_int *lda);
+void BLAS(scal)(const blas_int *n, const scs_float *sa, scs_float *sx,
+                const blas_int *incx);
+scs_float BLAS(nrm2)(const blas_int *n, scs_float *x, const blas_int *incx);
+#endif
+
+static scs_int get_sd_cone_size(scs_int s) { return (s * (s + 1)) / 2; }
+
+/*
+ * boundaries will contain array of indices of rows of A corresponding to
+ * cone boundaries, boundaries[0] is starting index for cones of size strictly
+ * larger than 1
+ * returns length of boundaries array, boundaries malloc-ed here so should be
+ * freed
+ */
+scs_int SCS(get_cone_boundaries)(const ScsCone *k, scs_int **boundaries) {
+  scs_int i, count = 0;
+  scs_int len = 1 + k->qsize + k->ssize + k->ed + k->ep + k->psize;
+  scs_int *b = (scs_int *)scs_calloc(len, sizeof(scs_int));
+  b[count] = k->f + k->l;
+  count += 1;
+  if (k->qsize > 0) {
+    memcpy(&b[count], k->q, k->qsize * sizeof(scs_int));
+  }
+  count += k->qsize;
+  for (i = 0; i < k->ssize; ++i) {
+    b[count + i] = get_sd_cone_size(k->s[i]);
+  }
+  count += k->ssize;
+  for (i = 0; i < k->ep + k->ed; ++i) {
+    b[count + i] = 3;
+  }
+  count += k->ep + k->ed;
+  for (i = 0; i < k->psize; ++i) {
+    b[count + i] = 3;
+  }
+  count += k->psize;
+  *boundaries = b;
+  return len;
+}
+
+static scs_int get_full_cone_dims(const ScsCone *k) {
+  scs_int i, c = 0;
+  if (k->f) {
+    c += k->f;
+  }
+  if (k->l) {
+    c += k->l;
+  }
+  if (k->qsize && k->q) {
+    for (i = 0; i < k->qsize; ++i) {
+      c += k->q[i];
+    }
+  }
+  if (k->ssize && k->s) {
+    for (i = 0; i < k->ssize; ++i) {
+      c += get_sd_cone_size(k->s[i]);
+    }
+  }
+  if (k->ed) {
+    c += 3 * k->ed;
+  }
+  if (k->ep) {
+    c += 3 * k->ep;
+  }
+  if (k->p) {
+    c += 3 * k->psize;
+  }
+  return c;
+}
+
+scs_int SCS(validate_cones)(const ScsData *d, const ScsCone *k) {
+  scs_int i;
+  if (get_full_cone_dims(k) != d->m) {
+    scs_printf("cone dimensions %li not equal to num rows in A = m = %li\n",
+               (long)get_full_cone_dims(k), (long)d->m);
+    return -1;
+  }
+  if (k->f && k->f < 0) {
+    scs_printf("free cone error\n");
+    return -1;
+  }
+  if (k->l && k->l < 0) {
+    scs_printf("lp cone error\n");
+    return -1;
+  }
+  if (k->qsize && k->q) {
+    if (k->qsize < 0) {
+      scs_printf("soc cone error\n");
+      return -1;
+    }
+    for (i = 0; i < k->qsize; ++i) {
+      if (k->q[i] < 0) {
+        scs_printf("soc cone error\n");
+        return -1;
+      }
+    }
+  }
+  if (k->ssize && k->s) {
+    if (k->ssize < 0) {
+      scs_printf("sd cone error\n");
+      return -1;
+    }
+    for (i = 0; i < k->ssize; ++i) {
+      if (k->s[i] < 0) {
+        scs_printf("sd cone error\n");
+        return -1;
+      }
+    }
+  }
+  if (k->ed && k->ed < 0) {
+    scs_printf("ep cone error\n");
+    return -1;
+  }
+  if (k->ep && k->ep < 0) {
+    scs_printf("ed cone error\n");
+    return -1;
+  }
+  if (k->psize && k->p) {
+    if (k->psize < 0) {
+      scs_printf("power cone error\n");
+      return -1;
+    }
+    for (i = 0; i < k->psize; ++i) {
+      if (k->p[i] < -1 || k->p[i] > 1) {
+        scs_printf("power cone error, values must be in [-1,1]\n");
+        return -1;
+      }
+    }
+  }
+  return 0;
+}
+
+char *SCS(get_cone_summary)(const ScsInfo *info, ScsConeWork *c) {
+  char *str = (char *)scs_malloc(sizeof(char) * 64);
+  sprintf(str, "\tCones: avg projection time: %1.2es\n",
+          c->total_cone_time / (info->iter + 1) / 1e3);
+  c->total_cone_time = 0.0;
+  return str;
+}
+
+void SCS(finish_cone)(ScsConeWork *c) {
+#ifdef USE_LAPACK
+  if (c->Xs) {
+    scs_free(c->Xs);
+  }
+  if (c->Z) {
+    scs_free(c->Z);
+  }
+  if (c->e) {
+    scs_free(c->e);
+  }
+  if (c->work) {
+    scs_free(c->work);
+  }
+  if (c->iwork) {
+    scs_free(c->iwork);
+  }
+#endif
+  if (c) {
+    scs_free(c);
+  }
+}
+
+char *SCS(get_cone_header)(const ScsCone *k) {
+  char *tmp = (char *)scs_malloc(sizeof(char) * 512);
+  scs_int i, soc_vars, soc_blks, sd_vars, sd_blks;
+  sprintf(tmp, "Cones:");
+  if (k->f) {
+    sprintf(tmp + strlen(tmp), "\tprimal zero / dual free vars: %li\n",
+            (long)k->f);
+  }
+  if (k->l) {
+    sprintf(tmp + strlen(tmp), "\tlinear vars: %li\n", (long)k->l);
+  }
+  soc_vars = 0;
+  soc_blks = 0;
+  if (k->qsize && k->q) {
+    soc_blks = k->qsize;
+    for (i = 0; i < k->qsize; i++) {
+      soc_vars += k->q[i];
+    }
+    sprintf(tmp + strlen(tmp), "\tsoc vars: %li, soc blks: %li\n",
+            (long)soc_vars, (long)soc_blks);
+  }
+  sd_vars = 0;
+  sd_blks = 0;
+  if (k->ssize && k->s) {
+    sd_blks = k->ssize;
+    for (i = 0; i < k->ssize; i++) {
+      sd_vars += get_sd_cone_size(k->s[i]);
+    }
+    sprintf(tmp + strlen(tmp), "\tsd vars: %li, sd blks: %li\n", (long)sd_vars,
+            (long)sd_blks);
+  }
+  if (k->ep || k->ed) {
+    sprintf(tmp + strlen(tmp), "\texp vars: %li, dual exp vars: %li\n",
+            (long)(3 * k->ep), (long)(3 * k->ed));
+  }
+  if (k->psize && k->p) {
+    sprintf(tmp + strlen(tmp), "\tprimal + dual power vars: %li\n",
+            (long)(3 * k->psize));
+  }
+  return tmp;
+}
+
+static scs_int is_simple_semi_definite_cone(scs_int *s, scs_int ssize) {
+  scs_int i;
+  for (i = 0; i < ssize; i++) {
+    if (s[i] > 2) {
+      return 0; /* false */
+    }
+  }
+  return 1; /* true */
+}
+
+static scs_float exp_newton_one_d(scs_float rho, scs_float y_hat,
+                                  scs_float z_hat) {
+  scs_float t = MAX(-z_hat, 1e-6);
+  scs_float f, fp;
+  scs_int i;
+  for (i = 0; i < EXP_CONE_MAX_ITERS; ++i) {
+    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) {
+      return 0;
+    } else if (t <= 0) {
+      return z_hat;
+    } else if (ABS(f) < CONE_TOL) {
+      break;
+    }
+  }
+  return t + z_hat;
+}
+
+static void exp_solve_for_x_with_rho(scs_float *v, scs_float *x,
+                                     scs_float rho) {
+  x[2] = exp_newton_one_d(rho, v[1], v[2]);
+  x[1] = (x[2] - v[2]) * x[2] / rho;
+  x[0] = v[0] - rho;
+}
+
+static scs_float exp_calc_grad(scs_float *v, scs_float *x, scs_float rho) {
+  exp_solve_for_x_with_rho(v, x, rho);
+  if (x[1] <= 1e-12) {
+    return x[0];
+  }
+  return x[0] + x[1] * log(x[1] / x[2]);
+}
+
+static void exp_get_rho_ub(scs_float *v, scs_float *x, scs_float *ub,
+                           scs_float *lb) {
+  *lb = 0;
+  *ub = 0.125;
+  while (exp_calc_grad(v, x, *ub) > 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];
+  scs_float tol = CONE_TOL; /* iter < 0 ? CONE_TOL : MAX(CONE_TOL, 1 /
+                               POWF((iter + 1), CONE_RATE)); */
+
+  /* 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); /* calculates gradient wrt dual var */
+    if (g > 0) {
+      lb = rho;
+    } else {
+      ub = rho;
+    }
+    if (ub - lb < tol) {
+      break;
+    }
+  }
+  /*
+#if EXTRA_VERBOSE > 0
+  scs_printf("exponential cone proj iters %i\n", i);
+#endif
+   */
+  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) {
+#ifdef USE_LAPACK
+  scs_int i;
+  blas_int n_max = 0;
+  scs_float eig_tol = 1e-8;
+  blas_int neg_one = -1;
+  blas_int m = 0;
+  blas_int info = 0;
+  scs_float wkopt = 0.0;
+#if EXTRA_VERBOSE > 0
+#define _STR_EXPAND(tok) #tok
+#define _STR(tok) _STR_EXPAND(tok)
+  scs_printf("BLAS(func) = '%s'\n", _STR(BLAS(func)));
+#endif
+  /* eigenvector decomp workspace */
+  for (i = 0; i < k->ssize; ++i) {
+    if (k->s[i] > n_max) {
+      n_max = (blas_int)k->s[i];
+    }
+  }
+  c->Xs = (scs_float *)scs_calloc(n_max * n_max, sizeof(scs_float));
+  c->Z = (scs_float *)scs_calloc(n_max * n_max, sizeof(scs_float));
+  c->e = (scs_float *)scs_calloc(n_max, sizeof(scs_float));
+  c->liwork = 0;
+
+  BLAS(syevr)
+  ("Vectors", "All", "Lower", &n_max, c->Xs, &n_max, SCS_NULL, SCS_NULL,
+   SCS_NULL, SCS_NULL, &eig_tol, &m, c->e, c->Z, &n_max, SCS_NULL, &wkopt,
+   &neg_one, &(c->liwork), &neg_one, &info);
+
+  if (info != 0) {
+    scs_printf("FATAL: syevr failure, info = %li\n", (long)info);
+    return -1;
+  }
+  c->lwork = (blas_int)(wkopt + 0.01); /* 0.01 for int casting safety */
+  c->work = (scs_float *)scs_calloc(c->lwork, sizeof(scs_float));
+  c->iwork = (blas_int *)scs_calloc(c->liwork, sizeof(blas_int));
+
+  if (!c->Xs || !c->Z || !c->e || !c->work || !c->iwork) {
+    return -1;
+  }
+  return 0;
+#else
+  scs_printf(
+      "FATAL: Cannot solve SDPs with > 2x2 matrices without linked "
+      "blas+lapack libraries\n");
+  scs_printf(
+      "Install blas+lapack and re-compile SCS with blas+lapack library "
+      "locations\n");
+  return -1;
+#endif
+}
+
+ScsConeWork *SCS(init_cone)(const ScsCone *k) {
+  ScsConeWork *c = (ScsConeWork *)scs_calloc(1, sizeof(ScsConeWork));
+#if EXTRA_VERBOSE > 0
+  scs_printf("init_cone\n");
+#endif
+  c->total_cone_time = 0.0;
+  if (k->ssize && k->s) {
+    if (!is_simple_semi_definite_cone(k->s, k->ssize) &&
+        set_up_sd_cone_work_space(c, k) < 0) {
+      SCS(finish_cone)(c);
+      return SCS_NULL;
+    }
+  }
+#if EXTRA_VERBOSE > 0
+  scs_printf("init_cone complete\n");
+#ifdef MATLAB_MEX_FILE
+  mexEvalString("drawnow;");
+#endif
+#endif
+  return c;
+}
+
+static scs_int project_2x2_sdc(scs_float *X) {
+  scs_float a, b, d, l1, l2, x1, x2, rad;
+  scs_float sqrt2 = SQRTF(2.0);
+  a = X[0];
+  b = X[1] / sqrt2;
+  d = X[2];
+
+  if (ABS(b) < 1e-6) { /* diagonal matrix */
+    X[0] = MAX(a, 0);
+    X[1] = 0;
+    X[2] = MAX(d, 0);
+    return 0;
+  }
+
+  rad = SQRTF((a - d) * (a - d) + 4 * b * b);
+  /* l1 >= l2 always, since rad >= 0 */
+  l1 = 0.5 * (a + d + rad);
+  l2 = 0.5 * (a + d - rad);
+
+#if EXTRA_VERBOSE > 0
+  scs_printf(
+      "2x2 SD: a = %4f, b = %4f, (X[1] = %4f, X[2] = %4f), d = %4f, "
+      "rad = %4f, l1 = %4f, l2 = %4f\n",
+      a, b, X[1], X[2], d, rad, l1, l2);
+#endif
+
+  if (l2 >= 0) { /* both eigs positive already */
+    return 0;
+  }
+  if (l1 <= 0) { /* both eigs negative, set to 0 */
+    X[0] = 0;
+    X[1] = 0;
+    X[2] = 0;
+    return 0;
+  }
+
+  /* l1 pos, l2 neg */
+  x1 = 1 / SQRTF(1 + (l1 - a) * (l1 - a) / b / b);
+  x2 = x1 * (l1 - a) / b;
+
+  X[0] = l1 * x1 * x1;
+  X[1] = (l1 * x1 * x2) * sqrt2;
+  X[2] = l1 * x2 * x2;
+  return 0;
+}
+
+/* size of X is get_sd_cone_size(n) */
+static scs_int proj_semi_definite_cone(scs_float *X, const scs_int n,
+                                       ScsConeWork *c) {
+/* project onto the positive semi-definite cone */
+#ifdef USE_LAPACK
+  scs_int i;
+  blas_int one = 1;
+  blas_int m = 0;
+  blas_int nb = (blas_int)n;
+  blas_int nb_plus_one = (blas_int)(n + 1);
+  blas_int cone_sz = (blas_int)(get_sd_cone_size(n));
+
+  scs_float sqrt2 = SQRTF(2.0);
+  scs_float sqrt2Inv = 1.0 / sqrt2;
+  scs_float *Xs = c->Xs;
+  scs_float *Z = c->Z;
+  scs_float *e = c->e;
+  scs_float *work = c->work;
+  blas_int *iwork = c->iwork;
+  blas_int lwork = c->lwork;
+  blas_int liwork = c->liwork;
+
+  scs_float eig_tol = CONE_TOL; /* iter < 0 ? CONE_TOL : MAX(CONE_TOL, 1 /
+                                  POWF(iter + 1, CONE_RATE)); */
+  scs_float zero = 0.0;
+  blas_int info = 0;
+  scs_float vupper = 0.0;
+#endif
+  if (n == 0) {
+    return 0;
+  }
+  if (n == 1) {
+    if (X[0] < 0.0) {
+      X[0] = 0.0;
+    }
+    return 0;
+  }
+  if (n == 2) {
+    return project_2x2_sdc(X);
+  }
+#ifdef USE_LAPACK
+
+  memset(Xs, 0, n * n * sizeof(scs_float));
+  /* expand lower triangular matrix to full matrix */
+  for (i = 0; i < n; ++i) {
+    memcpy(&(Xs[i * (n + 1)]), &(X[i * n - ((i - 1) * i) / 2]),
+           (n - i) * sizeof(scs_float));
+  }
+  /*
+     rescale so projection works, and matrix norm preserved
+     see http://www.seas.ucla.edu/~vandenbe/publications/mlbook.pdf pg 3
+   */
+  /* scale diags by sqrt(2) */
+  BLAS(scal)(&nb, &sqrt2, Xs, &nb_plus_one); /* not n_squared */
+
+  /* max-eig upper bounded by frobenius norm */
+  vupper = 1.1 * sqrt2 *
+           BLAS(nrm2)(&cone_sz, X,
+                      &one); /* mult by factor to make sure is upper bound */
+  vupper = MAX(vupper, 0.01);
+#if EXTRA_VERBOSE > 0
+  SCS(print_array)(Xs, n * n, "Xs");
+  SCS(print_array)(X, get_sd_cone_size(n), "X");
+#endif
+  /* Solve eigenproblem, reuse workspaces */
+  BLAS(syevr)
+  ("Vectors", "VInterval", "Lower", &nb, Xs, &nb, &zero, &vupper, SCS_NULL,
+   SCS_NULL, &eig_tol, &m, e, Z, &nb, SCS_NULL, work, &lwork, iwork, &liwork,
+   &info);
+#if EXTRA_VERBOSE > 0
+  if (info != 0) {
+    scs_printf("WARN: LAPACK syevr error, info = %i\n", info);
+  }
+  scs_printf("syevr input parameter dump:\n");
+  scs_printf("nb = %li\n", (long)nb);
+  scs_printf("lwork = %li\n", (long)lwork);
+  scs_printf("liwork = %li\n", (long)liwork);
+  scs_printf("vupper = %f\n", vupper);
+  scs_printf("eig_tol = %e\n", eig_tol);
+  SCS(print_array)(e, m, "e");
+  SCS(print_array)(Z, m * n, "Z");
+#endif
+  if (info < 0) {
+    return -1;
+  }
+
+  memset(Xs, 0, n * n * sizeof(scs_float));
+  for (i = 0; i < m; ++i) {
+    scs_float a = e[i];
+    BLAS(syr)("Lower", &nb, &a, &(Z[i * n]), &one, Xs, &nb);
+  }
+  /* scale diags by 1/sqrt(2) */
+  BLAS(scal)(&nb, &sqrt2Inv, Xs, &nb_plus_one); /* not n_squared */
+  /* extract just lower triangular matrix */
+  for (i = 0; i < n; ++i) {
+    memcpy(&(X[i * n - ((i - 1) * i) / 2]), &(Xs[i * (n + 1)]),
+           (n - i) * sizeof(scs_float));
+  }
+
+#if EXTRA_VERBOSE > 0
+  SCS(print_array)(Xs, n * n, "Xs");
+  SCS(print_array)(X, get_sd_cone_size(n), "X");
+#endif
+
+#else
+  scs_printf(
+      "FAILURE: solving SDP with > 2x2 matrices, but no blas/lapack "
+      "libraries were linked!\n");
+  scs_printf("SCS will return nonsense!\n");
+  SCS(scale_array)(X, NAN, n);
+  return -1;
+#endif
+  return 0;
+}
+
+static scs_float pow_calc_x(scs_float r, scs_float xh, scs_float rh,
+                            scs_float a) {
+  scs_float x = 0.5 * (xh + SQRTF(xh * xh + 4 * a * (rh - r) * r));
+  return MAX(x, 1e-12);
+}
+
+static scs_float pow_calcdxdr(scs_float x, scs_float xh, scs_float rh,
+                              scs_float r, scs_float a) {
+  return a * (rh - 2 * r) / (2 * x - xh);
+}
+
+static scs_float pow_calc_f(scs_float x, scs_float y, scs_float r,
+                            scs_float a) {
+  return POWF(x, a) * POWF(y, (1 - a)) - r;
+}
+
+static scs_float pow_calc_fp(scs_float x, scs_float y, scs_float dxdr,
+                             scs_float dydr, scs_float a) {
+  return POWF(x, a) * POWF(y, (1 - a)) * (a * dxdr / x + (1 - a) * dydr / y) -
+         1;
+}
+
+static void proj_power_cone(scs_float *v, scs_float a) {
+  scs_float xh = v[0], yh = v[1], rh = ABS(v[2]);
+  scs_float x = 0.0, y = 0.0, r;
+  scs_int i;
+  /* v in K_a */
+  if (xh >= 0 && yh >= 0 &&
+      CONE_THRESH + 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) >=
+          rh * POWF(a, a) * POWF(1 - a, 1 - a)) {
+    v[0] = v[1] = v[2] = 0;
+    return;
+  }
+
+  r = rh / 2;
+  for (i = 0; i < POW_CONE_MAX_ITERS; ++i) {
+    scs_float f, fp, dxdr, dydr;
+    x = pow_calc_x(r, xh, rh, a);
+    y = pow_calc_x(r, yh, rh, 1 - a);
+
+    f = pow_calc_f(x, y, r, a);
+    if (ABS(f) < CONE_TOL) {
+      break;
+    }
+
+    dxdr = pow_calcdxdr(x, xh, rh, r, a);
+    dydr = pow_calcdxdr(y, yh, rh, r, (1 - a));
+    fp = pow_calc_fp(x, y, dxdr, dydr, a);
+
+    r = MAX(r - f / fp, 0);
+    r = MIN(r, rh);
+  }
+  v[0] = x;
+  v[1] = y;
+  v[2] = (v[2] < 0) ? -(r) : (r);
+}
+
+/* outward facing cone projection routine, iter is outer algorithm iteration, if
+   iter < 0 then iter is ignored
+    warm_start contains guess of projection (can be set to SCS_NULL) */
+scs_int SCS(proj_dual_cone)(scs_float *x, const ScsCone *k, ScsConeWork *c,
+                            const scs_float *warm_start, scs_int iter) {
+  scs_int i;
+  scs_int count = (k->f ? k->f : 0);
+  SCS(timer) cone_timer;
+#if EXTRA_VERBOSE > 0
+  SCS(timer) proj_timer;
+  SCS(tic)(&proj_timer);
+#endif
+  SCS(tic)(&cone_timer);
+
+  if (k->l) {
+    /* project onto positive orthant */
+    for (i = count; i < count + k->l; ++i) {
+      if (x[i] < 0.0) {
+        x[i] = 0.0;
+      }
+      /* x[i] = (x[i] < 0.0) ? 0.0 : x[i]; */
+    }
+    count += k->l;
+#if EXTRA_VERBOSE > 0
+    scs_printf("pos orthant proj time: %1.2es\n", SCS(tocq)(&proj_timer) / 1e3);
+    SCS(tic)(&proj_timer);
+#endif
+  }
+
+  if (k->qsize && k->q) {
+    /* project onto SOC */
+    for (i = 0; i < k->qsize; ++i) {
+      if (k->q[i] == 0) {
+        continue;
+      }
+      if (k->q[i] == 1) {
+        if (x[count] < 0.0) {
+          x[count] = 0.0;
+        }
+      } else {
+        scs_float v1 = x[count];
+        scs_float s = SCS(norm)(&(x[count + 1]), k->q[i] - 1);
+        scs_float alpha = (s + v1) / 2.0;
+
+        if (s <= v1) { /* do nothing */
+        } else if (s <= -v1) {
+          memset(&(x[count]), 0, k->q[i] * sizeof(scs_float));
+        } else {
+          x[count] = alpha;
+          SCS(scale_array)(&(x[count + 1]), alpha / s, k->q[i] - 1);
+        }
+      }
+      count += k->q[i];
+    }
+#if EXTRA_VERBOSE > 0
+    scs_printf("SOC proj time: %1.2es\n", SCS(tocq)(&proj_timer) / 1e3);
+    SCS(tic)(&proj_timer);
+#endif
+  }
+
+  if (k->ssize && k->s) {
+    /* project onto PSD cone */
+    for (i = 0; i < k->ssize; ++i) {
+#if EXTRA_VERBOSE > 0
+      scs_printf("SD proj size %li\n", (long)k->s[i]);
+#endif
+      if (k->s[i] == 0) {
+        continue;
+      }
+      if (proj_semi_definite_cone(&(x[count]), k->s[i], c) < 0) {
+        return -1;
+      }
+      count += get_sd_cone_size(k->s[i]);
+    }
+#if EXTRA_VERBOSE > 0
+    scs_printf("SD proj time: %1.2es\n", SCS(tocq)(&proj_timer) / 1e3);
+    SCS(tic)(&proj_timer);
+#endif
+  }
+
+  if (k->ep) {
+    scs_float r, s, t;
+    scs_int idx;
+    /*
+     * 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(scale_array)(&(x[count]), -1, 3 * k->ep); /* x = -x; */
+#ifdef _OPENMP
+#pragma omp parallel for private(r, s, t, idx)
+#endif
+    for (i = 0; i < k->ep; ++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->ep;
+#if EXTRA_VERBOSE > 0
+    scs_printf("EP proj time: %1.2es\n", SCS(tocq)(&proj_timer) / 1e3);
+    SCS(tic)(&proj_timer);
+#endif
+  }
+
+  if (k->ed) {
+/* exponential cone: */
+#ifdef _OPENMP
+#pragma omp parallel for
+#endif
+    for (i = 0; i < k->ed; ++i) {
+      proj_exp_cone(&(x[count + 3 * i]));
+    }
+    count += 3 * k->ed;
+#if EXTRA_VERBOSE > 0
+    scs_printf("ED proj time: %1.2es\n", SCS(tocq)(&proj_timer) / 1e3);
+    SCS(tic)(&proj_timer);
+#endif
+  }
+
+  if (k->psize && k->p) {
+    scs_float v[3];
+    scs_int idx;
+    /* don't use openmp for power cone
+    ifdef _OPENMP
+    pragma omp parallel for private(v, idx)
+    endif
+    */
+    for (i = 0; i < k->psize; ++i) {
+      idx = count + 3 * i;
+      if (k->p[i] <= 0) {
+        /* dual power cone */
+        proj_power_cone(&(x[idx]), -k->p[i]);
+      } else {
+        /* primal power cone, using Moreau */
+        v[0] = -x[idx];
+        v[1] = -x[idx + 1];
+        v[2] = -x[idx + 2];
+
+        proj_power_cone(v, k->p[i]);
+
+        x[idx] += v[0];
+        x[idx + 1] += v[1];
+        x[idx + 2] += v[2];
+      }
+    }
+    count += 3 * k->psize;
+#if EXTRA_VERBOSE > 0
+    scs_printf("Power cone proj time: %1.2es\n", SCS(tocq)(&proj_timer) / 1e3);
+    SCS(tic)(&proj_timer);
+#endif
+  }
+  /* project onto OTHER cones */
+  if (c) {
+    c->total_cone_time += SCS(tocq)(&cone_timer);
+  }
+  return 0;
+}