scs 0.4.0 → 0.4.1

data/vendor/scs/Makefile

@@ -1,7 +1,7 @@
 # MAKEFILE for scs
 include scs.mk
 
-SCS_OBJECTS = src/util.o src/cones.o src/aa.o src/rw.o src/linalg.o src/ctrlc.o src/scs_version.o src/normalize.o
+SCS_OBJECTS = src/util.o src/cones.o src/exp_cone.o src/aa.o src/rw.o src/linalg.o src/ctrlc.o src/scs_version.o src/normalize.o
 SCS_O = src/scs.o
 SCS_INDIR_O = src/scs_indir.o
 
@@ -19,7 +19,7 @@ TARGETS = $(OUT)/demo_socp_indirect $(OUT)/demo_socp_direct $(OUT)/run_from_file
 default: $(TARGETS) $(OUT)/libscsdir.a $(OUT)/libscsindir.a $(OUT)/libscsdir.$(SHARED) $(OUT)/libscsindir.$(SHARED)
 	@echo "****************************************************************************************"
 	@echo "Successfully compiled scs, copyright Brendan O'Donoghue 2012."
-	@echo "To test, type '$(OUT)/demo_socp_direct' to solve a random SOCP."
+	@echo "To test, run 'make test' and then '$(OUT)/run_tests_direct'."
 	@echo "**********************************************************************************"
 ifneq ($(USE_LAPACK), 0)
 	@echo "Compiled with blas and lapack, can solve LPs, SOCPs, SDPs, ECPs, and PCPs"
@@ -41,6 +41,7 @@ $(SCS_INDIR_O): src/scs.c $(INC_FILES)
 
 src/util.o	: src/util.c $(INC_FILES)
 src/cones.o	: src/cones.c $(INC_FILES)
+src/exp_cone.o	: src/exp_cone.c $(INC_FILES)
 src/aa.o	: src/aa.c $(INC_FILES)
 src/rw.o	: src/rw.c $(INC_FILES)
 src/linalg.o: src/linalg.c $(INC_FILES)
@@ -49,6 +50,7 @@ src/scs_version.o: src/scs_version.c $(INC_FILES)
 
 $(DIRSRC)/private.o: $(DIRSRC)/private.c  $(DIRSRC)/private.h
 $(INDIRSRC)/indirect/private.o: $(INDIRSRC)/private.c $(INDIRSRC)/private.h
+$(MKLSRC)/private.o: $(MKLSRC)/private.c  $(MKLSRC)/private.h
 $(LINSYS)/scs_matrix.o: $(LINSYS)/scs_matrix.c $(LINSYS)/scs_matrix.h
 $(LINSYS)/csparse.o: $(LINSYS)/csparse.c $(LINSYS)/csparse.h
 
@@ -62,45 +64,68 @@ $(OUT)/libscsindir.a: $(SCS_INDIR_O) $(SCS_OBJECTS) $(INDIRSRC)/private.o $(LINS
 	$(ARCHIVE) $@ $^
 	- $(RANLIB) $@
 
+$(OUT)/libscsmkl.a: $(SCS_O) $(SCS_OBJECTS) $(MKLSRC)/private.o $(LINSYS)/scs_matrix.o $(LINSYS)/csparse.o
+	mkdir -p $(OUT)
+	$(ARCHIVE) $@ $^
+	- $(RANLIB) $@
+
 $(OUT)/libscsdir.$(SHARED): $(SCS_O) $(SCS_OBJECTS) $(DIRSRC)/private.o $(AMD_OBJS) $(LDL_OBJS) $(LINSYS)/scs_matrix.o $(LINSYS)/csparse.o
 	mkdir -p $(OUT)
-	$(CC) $(CFLAGS) -shared -Wl,$(SONAME),$(@:$(OUT)/%=%) -o $@ $^ $(LDFLAGS)
+	$(CC) $(CFLAGS) -shared -Wl,$(SONAME),$(@:$(OUT)/%=%) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS)
 
 $(OUT)/libscsindir.$(SHARED): $(SCS_INDIR_O) $(SCS_OBJECTS) $(INDIRSRC)/private.o $(LINSYS)/scs_matrix.o $(LINSYS)/csparse.o
 	mkdir -p $(OUT)
-	$(CC) $(CFLAGS) -shared -Wl,$(SONAME),$(@:$(OUT)/%=%) -o $@ $^ $(LDFLAGS)
+	$(CC) $(CFLAGS) -shared -Wl,$(SONAME),$(@:$(OUT)/%=%) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS)
+
+$(OUT)/libscsmkl.$(SHARED): $(SCS_O) $(SCS_OBJECTS) $(MKLSRC)/private.o $(LINSYS)/scs_matrix.o $(LINSYS)/csparse.o
+	mkdir -p $(OUT)
+	$(CC) $(CFLAGS) -shared -Wl,$(SONAME),$(@:$(OUT)/%=%) -o $@ $^ $(LDFLAGS) $(MKLFLAGS)
 
 $(OUT)/demo_socp_direct: test/random_socp_prob.c $(OUT)/libscsdir.a
-	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS)
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS)
 
 $(OUT)/demo_socp_indirect: test/random_socp_prob.c $(OUT)/libscsindir.a
-	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS)
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS)
+
+$(OUT)/demo_socp_mkl: test/random_socp_prob.c $(OUT)/libscsmkl.a
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(MKLFLAGS)
 
 $(OUT)/run_from_file_direct: test/run_from_file.c $(OUT)/libscsdir.a
-	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS)
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS)
 
 $(OUT)/run_from_file_indirect: test/run_from_file.c $(OUT)/libscsindir.a
-	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS)
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS)
 
 $(OUT)/run_from_file_gpu_indirect: test/run_from_file.c $(OUT)/libscsgpuindir.a
-	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(CULDFLAGS)
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS) $(CULDFLAGS)
 
 # basic testing
 .PHONY: test
 test: $(OUT)/run_tests_indirect $(OUT)/run_tests_direct
 $(OUT)/run_tests_indirect: test/run_tests.c $(OUT)/libscsindir.a
-	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) -Itest
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS) -Itest
 $(OUT)/run_tests_direct: test/run_tests.c $(OUT)/libscsdir.a
-	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) -Itest
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS) -Itest
+$(OUT)/run_tests_mkl: test/run_tests.c $(OUT)/libscsmkl.a
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(MKLFLAGS) -Itest
+
 
 .PHONY: test_gpu
 test_gpu: $(OUT)/run_tests_gpu_indirect # $(OUT)/run_tests_gpu_direct
 
+.PHONY: mkl
+mkl: mklroot $(OUT)/libscsmkl.a $(OUT)/libscsmkl.$(SHARED) $(OUT)/run_tests_mkl $(OUT)/demo_socp_mkl
+mklroot:
+ifndef MKLROOT
+	$(error MKLROOT is undefined, set MKLROOT to the MKL install location)
+endif
+
+
 $(OUT)/run_tests_gpu_indirect: test/run_tests.c $(OUT)/libscsgpuindir.a
-	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(CULDFLAGS) -Itest
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS) $(CULDFLAGS) -Itest
 
 # $(OUT)/run_tests_gpu_direct: test/run_tests.c $(OUT)/libscsgpudir.a
-# 	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(CULDFLAGS) -Itest
+# 	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS) $(CULDFLAGS) -Itest
 
 # REQUIRES GPU AND CUDA INSTALLED
 gpu: gpu_indirect # gpu_direct
@@ -119,7 +144,7 @@ $(GPUINDIR)/private.o: $(GPUINDIR)/private.c
 
 # $(OUT)/libscsgpudir.$(SHARED): $(SCS_O) $(SCS_OBJECTS) $(GPUDIR)/private.o $(AMD_OBJS) $(LINSYS)/scs_matrix.o $(LINSYS)/gpu/gpu.o
 #	 mkdir -p $(OUT)
-# 	$(CC) $(CFLAGS) -shared -Wl,$(SONAME),$(@:$(OUT)/%=%) -o $@ $^ $(LDFLAGS) $(CULDFLAGS)
+# 	$(CC) $(CFLAGS) -shared -Wl,$(SONAME),$(@:$(OUT)/%=%) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS) $(CULDFLAGS)
 
 # $(OUT)/libscsgpudir.a: $(SCS_INDIR_O) $(SCS_OBJECTS) $(GPUDIR)/private.o $(AMD_OBJS) $(LINSYS)/scs_matrix.o $(LINSYS)/gpu/gpu.o
 #  	mkdir -p $(OUT)
@@ -128,7 +153,7 @@ $(GPUINDIR)/private.o: $(GPUINDIR)/private.c
 
 $(OUT)/libscsgpuindir.$(SHARED): $(SCS_O) $(SCS_OBJECTS) $(GPUINDIR)/private.o $(LINSYS)/scs_matrix.o $(LINSYS)/csparse.o $(LINSYS)/gpu/gpu.o
 	mkdir -p $(OUT)
-	$(CC) $(CFLAGS) -shared -Wl,$(SONAME),$(@:$(OUT)/%=%) -o $@ $^ $(LDFLAGS) $(CULDFLAGS)
+	$(CC) $(CFLAGS) -shared -Wl,$(SONAME),$(@:$(OUT)/%=%) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS) $(CULDFLAGS)
 
 $(OUT)/libscsgpuindir.a: $(SCS_INDIR_O) $(SCS_OBJECTS) $(GPUINDIR)/private.o $(LINSYS)/scs_matrix.o $(LINSYS)/csparse.o $(LINSYS)/gpu/gpu.o
 	mkdir -p $(OUT)
@@ -136,14 +161,14 @@ $(OUT)/libscsgpuindir.a: $(SCS_INDIR_O) $(SCS_OBJECTS) $(GPUINDIR)/private.o $(L
 	- $(RANLIB) $@
 
 # $(OUT)/demo_socp_gpu_direct: test/random_socp_prob.c $(OUT)/libscsgpudir.a
-# 	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(CULDFLAGS)
+# 	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS) $(CULDFLAGS)
 
 $(OUT)/demo_socp_gpu_indirect: test/random_socp_prob.c $(OUT)/libscsgpuindir.a
-	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(CULDFLAGS)
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS) $(CULDFLAGS)
 
 .PHONY: clean purge
 clean:
-	@rm -rf $(TARGETS) $(SCS_O) $(SCS_INDIR_O) $(SCS_OBJECTS) $(AMD_OBJS) $(LDL_OBJS) $(LINSYS)/*.o $(DIRSRC)/*.o $(INDIRSRC)/*.o $(GPUDIR)/*.o $(GPUINDIR)/*.o $(LINSYS)/gpu/*.o
+	@rm -rf $(TARGETS) $(SCS_O) $(SCS_INDIR_O) $(SCS_OBJECTS) $(AMD_OBJS) $(LDL_OBJS) $(LINSYS)/*.o $(DIRSRC)/*.o $(INDIRSRC)/*.o $(MKLSRC)/*.o $(GPUDIR)/*.o $(GPUINDIR)/*.o $(LINSYS)/gpu/*.o
 	@rm -rf $(OUT)/*.dSYM
 	@rm -rf matlab/*.mex*
 	@rm -rf .idea

data/vendor/scs/README.md

@@ -8,7 +8,7 @@
 
 
 SCS (`splitting conic solver`) is a numerical optimization package for solving
-large-scale convex cone problems. The current version is `3.2.0`.
+large-scale convex cone problems. The current version is `3.2.3`.
 
 The full documentation is available [here](https://www.cvxgrp.org/scs/).
 

data/vendor/scs/include/glbopts.h

@@ -12,16 +12,17 @@ extern "C" {
 #define SCS(x) _scs_##x
 #endif
 
-/* SCS VERSION NUMBER ----------------------------------------------    */
+/* SCS VERSION NUMBER ----------------------------------------------     */
 /* string literals automatically null-terminated */
-#define SCS_VERSION ("3.2.0")
+#define SCS_VERSION ("3.2.3")
 
 /* verbosity level */
 #ifndef VERBOSITY
 #define VERBOSITY (0)
 #endif
 
-/* DEFAULT SOLVER PARAMETERS AND SETTINGS --------------------------    */
+/* DEFAULT SOLVER PARAMETERS AND SETTINGS --------------------------     */
+/* If you update any of these you must update the documentation manually */
 #define MAX_ITERS (100000)
 #define EPS_REL (1E-4)
 #define EPS_ABS (1E-4)
@@ -39,14 +40,13 @@ extern "C" {
 #define LOG_CSV_FILENAME (0)
 #define TIME_LIMIT_SECS (0.)
 
-/* redefine printfs and memory allocators as needed */
+/* redefine printfs as needed */
+#if NO_PRINTING > 0     /* Disable all printing */
+#define scs_printf(...) /* No-op */
+#else
 #ifdef MATLAB_MEX_FILE
 #include "mex.h"
 #define scs_printf mexPrintf
-#define scs_free mxFree
-#define scs_malloc mxMalloc
-#define scs_calloc mxCalloc
-#define scs_realloc mxRealloc
 #elif defined PYTHON
 #include <Python.h>
 /* see:
@@ -58,6 +58,27 @@ extern "C" {
     PySys_WriteStdout(__VA_ARGS__);                                            \
     PyGILState_Release(gilstate);                                              \
   }
+#elif defined R_LANG
+#include <R_ext/Print.h> /* Rprintf etc */
+#include <stdio.h>
+#include <stdlib.h>
+#define scs_printf Rprintf
+#else
+#include <stdio.h>
+#include <stdlib.h>
+#define scs_printf printf
+#endif
+#endif
+
+/* redefine memory allocators as needed */
+#ifdef MATLAB_MEX_FILE
+#include "mex.h"
+#define scs_free mxFree
+#define scs_malloc mxMalloc
+#define scs_calloc mxCalloc
+#define scs_realloc mxRealloc
+#elif defined PYTHON
+#include <Python.h>
 #if PY_MAJOR_VERSION >= 3
 #define scs_free PyMem_RawFree
 #define scs_malloc PyMem_RawMalloc
@@ -74,10 +95,8 @@ static inline void *scs_calloc(size_t count, size_t size) {
 }
 #endif
 #elif defined R_LANG
-#include <R_ext/Print.h> /* Rprintf etc */
 #include <stdio.h>
 #include <stdlib.h>
-#define scs_printf Rprintf
 #define scs_free free
 #define scs_malloc malloc
 #define scs_calloc calloc
@@ -85,7 +104,6 @@ static inline void *scs_calloc(size_t count, size_t size) {
 #else
 #include <stdio.h>
 #include <stdlib.h>
-#define scs_printf printf
 #define scs_free free
 #define scs_malloc malloc
 #define scs_calloc calloc
@@ -144,8 +162,9 @@ static inline void *scs_calloc(size_t count, size_t size) {
 /* how many iterations between heuristic residual rescaling */
 #define RESCALING_MIN_ITERS (100)
 
-#define EPS_TOL (1E-18)
-#define SAFEDIV_POS(X, Y) ((Y) < EPS_TOL ? ((X) / EPS_TOL) : (X) / (Y))
+#define _DIV_EPS_TOL (1E-18)
+#define SAFEDIV_POS(X, Y)                                                      \
+  ((Y) < _DIV_EPS_TOL ? ((X) / _DIV_EPS_TOL) : (X) / (Y))
 
 #if VERBOSITY > 0
 #define PRINT_INTERVAL (1)

data/vendor/scs/include/linsys.h

@@ -23,15 +23,15 @@ extern "C" {
  *  @return            Linear system solver workspace.
  *
  */
-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);
 
 /**
  * Frees `ScsLinSysWork` structure and associated allocated memory.
  *
  *  @param  w    Linear system private workspace.
  */
-void SCS(free_lin_sys_work)(ScsLinSysWork *w);
+void scs_free_lin_sys_work(ScsLinSysWork *w);
 
 /**
  * Solves the linear system as required by SCS at each iteration:
@@ -48,11 +48,11 @@ void SCS(free_lin_sys_work)(ScsLinSysWork *w);
  *  @param  b    Right hand side, contains solution at the end.
  *  @param  s    Contains warm-start (may be NULL).
  *  @param  tol  Tolerance required for the system solve.
- *  @return status < 0 indicates failure.
+ *  @return status != 0 indicates failure.
  *
  */
-scs_int SCS(solve_lin_sys)(ScsLinSysWork *w, scs_float *b, const scs_float *s,
-                           scs_float tol);
+scs_int scs_solve_lin_sys(ScsLinSysWork *w, scs_float *b, const scs_float *s,
+                          scs_float tol);
 /**
  *  Update the linsys workspace when `R` is changed. For example, a
  *  direct method for solving the linear system might need to update the
@@ -62,14 +62,14 @@ scs_int SCS(solve_lin_sys)(ScsLinSysWork *w, scs_float *b, const scs_float *s,
  *  @param  new_diag_r    Updated `diag_r`, diagonal entries of R.
  *
  */
-void SCS(update_lin_sys_diag_r)(ScsLinSysWork *w, const scs_float *new_diag_r);
+void scs_update_lin_sys_diag_r(ScsLinSysWork *w, const scs_float *new_diag_r);
 
 /**
  * Name of the linear solver.
  *
  * @return name of method.
  */
-const char *SCS(get_lin_sys_method)(void);
+const char *scs_get_lin_sys_method(void);
 
 #ifdef __cplusplus
 }

data/vendor/scs/include/scs.h

@@ -1,5 +1,9 @@
-/* This file contains the outward facing SCS API. */
-/* It includes all the input/output data structs and the API functions. */
+/*
+ * Public header containing the outward facing SCS API. It includes all the
+ * input/output data structs and the API functions.  Make sure this file and
+ * `scs_types.h` are somewhere appropriate and then use `#include "scs.h"` to
+ * access the SCS public API.
+ */
 
 #ifndef SCS_H_GUARD
 #define SCS_H_GUARD

data/vendor/scs/include/scs_types.h

@@ -1,5 +1,7 @@
 /*
- * Definitions of primitive types used in SCS.
+ * Pulic header including definitions of primitive types used in SCS.
+ * Make sure this file and `scs.h` are somewhere appropriate and then use
+ * `#include "scs.h"` to access the SCS public API.
  */
 
 #ifndef SCS_TYPES_H_GUARD

data/vendor/scs/include/scs_work.h

@@ -54,14 +54,15 @@ struct SCS_WORK {
   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) */
-  scs_float *b_orig, *c_orig; /* original unnormalized b and c vectors */
-  AaWork *accel;              /* struct for acceleration workspace */
-  ScsData *d;                 /* Problem data deep copy NORMALIZED */
-  ScsCone *k;                 /* Problem cone deep copy */
-  ScsSettings *stgs;          /* contains solver settings specified by user */
-  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_float *b_orig, *c_orig;     /* original unnormalized b and c vectors */
+  scs_float nm_b_orig, nm_c_orig; /* unnormalized NORM(b), NORM(c) */
+  AaWork *accel;                  /* struct for acceleration workspace */
+  ScsData *d;                     /* Problem data deep copy NORMALIZED */
+  ScsCone *k;                     /* Problem cone deep copy */
+  ScsSettings *stgs;      /* contains solver settings specified by user */
+  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 */

data/vendor/scs/include/util.h

@@ -11,7 +11,7 @@ extern "C" {
 #include <stdlib.h>
 
 /* timing code courtesy of A. Domahidi */
-#if (defined NOTIMER)
+#if (defined NO_TIMER)
 typedef void *SCS(timer);
 #elif (defined _WIN32 || defined _WIN64 || defined _WINDLL)
 /* Use Windows QueryPerformanceCounter for timing */

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

@@ -1,20 +1,10 @@
 #include "private.h"
-#include "linsys.h"
 
-const char *SCS(get_lin_sys_method)() {
-  return "sparse-direct";
+const char *scs_get_lin_sys_method() {
+  return "sparse-direct-amd-qdldl";
 }
 
-/*
-char *SCS(get_lin_sys_summary)(ScsLinSysWork *p, const ScsInfo *info) {
-  char *str = (char *)scs_malloc(sizeof(char) * 128);
-  scs_int n = p->L->n;
-  sprintf(str, "lin-sys: nnz(L): %li\n", (long)(p->L->p[n] + n));
-  return str;
-}
-*/
-
-void SCS(free_lin_sys_work)(ScsLinSysWork *p) {
+void scs_free_lin_sys_work(ScsLinSysWork *p) {
   if (p) {
     SCS(cs_spfree)(p->L);
     SCS(cs_spfree)(p->kkt);
@@ -33,155 +23,43 @@ void SCS(free_lin_sys_work)(ScsLinSysWork *p) {
   }
 }
 
-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
-   *
-   * forms upper triangular part of [(I + P)  A'; A -I]
-   * P : n x n, A: m x n.
-   */
-  scs_int h, i, j, count;
-  csc *Kcsc, *K;
-  scs_int n = A->n;
-  scs_int m = A->m;
-  scs_int Anz = A->p[n];
-  scs_int Knzmax;
-  scs_int *idx_mapping;
-  if (P) {
-    /* Upper bound P + I upper triangular component as Pnz + n */
-    Knzmax = n + m + Anz + P->p[n];
-  } else {
-    Knzmax = n + m + Anz;
-  }
-  K = SCS(cs_spalloc)(m + n, m + n, Knzmax, 1, 1);
-
-#if VERBOSITY > 0
-  scs_printf("forming kkt\n");
-#endif
-  /* Here we generate a triplet matrix and then compress to CSC */
-  if (!K) {
-    return SCS_NULL;
-  }
-
-  count = 0; /* element counter */
-  if (P) {
-    /* 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[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 (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[count] = i;
-        K->p[count] = j;
-        K->x[count] = P->x[h];
-        if (i == j) {
-          /* P has diagonal element */
-          diag_p[j] = P->x[h];
-          K->x[count] += diag_r[j];
-          diag_r_idxs[j] = count; /* store the indices where diag_r occurs */
-        }
-        count++;
-        /* reached the end without adding diagonal, do it now */
-        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 {
-    /* 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 (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++;
-    }
-  }
-
-  /* -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 = count;
-  idx_mapping = (scs_int *)scs_calloc(K->nz, sizeof(scs_int));
-  Kcsc = SCS(cs_compress)(K, idx_mapping);
-  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);
-  return Kcsc;
-}
-
-static scs_int _ldl_init(csc *A, scs_int *P, scs_float **info) {
+static scs_int _ldl_init(ScsMatrix *A, scs_int *P, scs_float **info) {
   *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);
 }
 
 /* call only once */
 static scs_int ldl_prepare(ScsLinSysWork *p) {
-  csc *kkt = p->kkt, *L = p->L;
-  scs_int n = kkt->n;
+  ScsMatrix *kkt = p->kkt, *L = p->L;
+  scs_int nzmax, n = kkt->n;
   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) {
+  nzmax = QDLDL_etree(n, kkt->p, kkt->i, p->iwork, p->Lnz, p->etree);
+  if (nzmax < 0) {
     scs_printf("Error in elimination tree calculation.\n");
-    if (L->nzmax == -1) {
+    if (nzmax == -1) {
       scs_printf("Matrix is not perfectly upper triangular.\n");
-    } else if (L->nzmax == -2) {
+    } else if (nzmax == -2) {
       scs_printf("Integer overflow in L nonzero count.\n");
     }
-    return L->nzmax;
+    return nzmax;
   }
 
-  L->x = (scs_float *)scs_calloc(L->nzmax, sizeof(scs_float));
-  L->i = (scs_int *)scs_calloc(L->nzmax, sizeof(scs_int));
+  L->x = (scs_float *)scs_calloc(nzmax, sizeof(scs_float));
+  L->i = (scs_int *)scs_calloc(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;
+  return nzmax;
 }
 
 /* can call many times */
 static scs_int ldl_factor(ScsLinSysWork *p, scs_int num_vars) {
   scs_int factor_status;
-  csc *kkt = p->kkt, *L = p->L;
+  ScsMatrix *kkt = p->kkt, *L = p->L;
 #if VERBOSITY > 0
   scs_printf("numeric factorization\n");
 #endif
@@ -217,7 +95,7 @@ static void _ldl_permt(scs_int n, scs_float *x, scs_float *b, scs_int *P) {
     x[P[j]] = b[j];
 }
 
-static void _ldl_solve(scs_float *b, csc *L, scs_float *Dinv, scs_int *P,
+static void _ldl_solve(scs_float *b, ScsMatrix *L, scs_float *Dinv, scs_int *P,
                        scs_float *bp) {
   /* solves PLDL'P' x = b for x */
   scs_int n = L->n;
@@ -240,11 +118,11 @@ static scs_int *cs_pinv(scs_int const *p, scs_int n) {
   return pinv;      /* return result */
 }
 
-static csc *cs_symperm(const csc *A, const scs_int *pinv, scs_int *idx_mapping,
-                       scs_int values) {
+static ScsMatrix *cs_symperm(const ScsMatrix *A, const scs_int *pinv,
+                             scs_int *idx_mapping, scs_int values) {
   scs_int i, j, p, q, i2, j2, n, *Ap, *Ai, *Cp, *Ci, *w;
   scs_float *Cx, *Ax;
-  csc *C;
+  ScsMatrix *C;
   n = A->n;
   Ap = A->p;
   Ai = A->i;
@@ -290,14 +168,16 @@ static csc *cs_symperm(const csc *A, const scs_int *pinv, scs_int *idx_mapping,
                       1); /* success; free workspace, return C */
 }
 
-static csc *permute_kkt(const ScsMatrix *A, const ScsMatrix *P,
-                        ScsLinSysWork *p, const scs_float *diag_r) {
+static ScsMatrix *permute_kkt(const ScsMatrix *A, const ScsMatrix *P,
+                              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, p->diag_p, diag_r, p->diag_r_idxs);
+  scs_int *Pinv, amd_status, *idx_mapping, i, kkt_nnz;
+  ScsMatrix *kkt_perm;
+  ScsMatrix *kkt = SCS(form_kkt)(A, P, p->diag_p, diag_r, p->diag_r_idxs, 1);
   if (!kkt) {
     return SCS_NULL;
   }
+  kkt_nnz = kkt->p[kkt->n];
   amd_status = _ldl_init(kkt, p->perm, &info);
   if (amd_status < 0) {
     scs_printf("AMD permutatation error.\n");
@@ -308,7 +188,7 @@ 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_calloc(kkt->nzmax, sizeof(scs_int));
+  idx_mapping = (scs_int *)scs_calloc(kkt_nnz, sizeof(scs_int));
   kkt_perm = cs_symperm(kkt, Pinv, idx_mapping, 1);
   for (i = 0; i < A->n + A->m; i++) {
     p->diag_r_idxs[i] = idx_mapping[p->diag_r_idxs[i]];
@@ -320,7 +200,7 @@ static csc *permute_kkt(const ScsMatrix *A, const ScsMatrix *P,
   return kkt_perm;
 }
 
-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, ldl_status;
   for (i = 0; i < p->n; ++i) {
     /* top left is R_x + P, bottom right is -R_y */
@@ -339,21 +219,20 @@ void SCS(update_lin_sys_diag_r)(ScsLinSysWork *p, const scs_float *diag_r) {
   }
 }
 
-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) {
   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->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->L = (ScsMatrix *)scs_calloc(1, sizeof(ScsMatrix));
   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, diag_r);
   ldl_prepare_status = ldl_prepare(p);
   ldl_status = ldl_factor(p, A->n);
@@ -366,8 +245,8 @@ ScsLinSysWork *SCS(init_lin_sys_work)(const ScsMatrix *A, const ScsMatrix *P,
   return p;
 }
 
-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) {
   /* returns solution to linear system */
   /* Ax = b with solution stored in b */
   _ldl_solve(b, p->L, p->Dinv, p->perm, p->bp);