scs 0.2.0

data/vendor/scs/src/scs_version.c

@@ -0,0 +1,5 @@
+#include "glbopts.h"
+
+const char *SCS(version)(void) { return SCS_VERSION; }
+size_t SCS(sizeof_int)(void) { return sizeof(scs_int); }
+size_t SCS(sizeof_float)(void) { return sizeof(scs_float); }

data/vendor/scs/src/util.c

@@ -0,0 +1,196 @@
+#include "util.h"
+
+#include "glbopts.h"
+#include "linsys.h"
+
+/* return milli-seconds */
+#if (defined NOTIMER)
+
+void SCS(tic)(SCS(timer) * t) {}
+scs_float SCS(tocq)(SCS(timer) * t) { return NAN; }
+
+#elif (defined _WIN32 || _WIN64 || defined _WINDLL)
+
+void SCS(tic)(SCS(timer) * t) {
+  QueryPerformanceFrequency(&t->freq);
+  QueryPerformanceCounter(&t->tic);
+}
+
+scs_float SCS(tocq)(SCS(timer) * t) {
+  QueryPerformanceCounter(&t->toc);
+  return (1e3 * (t->toc.QuadPart - t->tic.QuadPart) /
+          (scs_float)t->freq.QuadPart);
+}
+
+#elif (defined __APPLE__)
+#include <stdint.h>
+
+void SCS(tic)(SCS(timer) * t) {
+  /* read current clock cycles */
+  t->tic = mach_absolute_time();
+}
+
+scs_float SCS(tocq)(SCS(timer) * t) {
+  uint64_t duration; /* elapsed time in clock cycles*/
+
+  t->toc = mach_absolute_time();
+  duration = t->toc - t->tic;
+
+  /*conversion from clock cycles to nanoseconds*/
+  mach_timebase_info(&(t->tinfo));
+  duration *= t->tinfo.numer;
+  duration /= t->tinfo.denom;
+
+  return (scs_float)duration / 1e6;
+}
+
+#else
+
+void SCS(tic)(SCS(timer) * t) { clock_gettime(CLOCK_MONOTONIC, &t->tic); }
+
+scs_float SCS(tocq)(SCS(timer) * t) {
+  struct timespec temp;
+
+  clock_gettime(CLOCK_MONOTONIC, &t->toc);
+
+  if ((t->toc.tv_nsec - t->tic.tv_nsec) < 0) {
+    temp.tv_sec = t->toc.tv_sec - t->tic.tv_sec - 1;
+    temp.tv_nsec = 1e9 + t->toc.tv_nsec - t->tic.tv_nsec;
+  } else {
+    temp.tv_sec = t->toc.tv_sec - t->tic.tv_sec;
+    temp.tv_nsec = t->toc.tv_nsec - t->tic.tv_nsec;
+  }
+  return (scs_float)temp.tv_sec * 1e3 + (scs_float)temp.tv_nsec / 1e6;
+}
+
+#endif
+
+scs_float SCS(toc)(SCS(timer) * t) {
+  scs_float time = SCS(tocq)(t);
+  scs_printf("time: %8.4f milli-seconds.\n", time);
+  return time;
+}
+
+scs_float SCS(str_toc)(char *str, SCS(timer) * t) {
+  scs_float time = SCS(tocq)(t);
+  scs_printf("%s - time: %8.4f milli-seconds.\n", str, time);
+  return time;
+}
+
+void SCS(print_cone_data)(const ScsCone *k) {
+  scs_int i;
+  scs_printf("num zeros = %i\n", (int)k->f);
+  scs_printf("num LP = %i\n", (int)k->l);
+  scs_printf("num SOCs = %i\n", (int)k->qsize);
+  scs_printf("soc array:\n");
+  for (i = 0; i < k->qsize; i++) {
+    scs_printf("%i\n", (int)k->q[i]);
+  }
+  scs_printf("num SDCs = %i\n", (int)k->ssize);
+  scs_printf("sdc array:\n");
+  for (i = 0; i < k->ssize; i++) {
+    scs_printf("%i\n", (int)k->s[i]);
+  }
+  scs_printf("num ep = %i\n", (int)k->ep);
+  scs_printf("num ed = %i\n", (int)k->ed);
+  scs_printf("num PCs = %i\n", (int)k->psize);
+  scs_printf("pow array:\n");
+  for (i = 0; i < k->psize; i++) {
+    scs_printf("%4f\n", (double)k->p[i]);
+  }
+}
+
+void SCS(print_work)(const ScsWork *w) {
+  scs_int i, l = w->n + w->m;
+  scs_printf("\n u_t is \n");
+  for (i = 0; i < l; i++) {
+    scs_printf("%f\n", w->u_t[i]);
+  }
+  scs_printf("\n u is \n");
+  for (i = 0; i < l; i++) {
+    scs_printf("%f\n", w->u[i]);
+  }
+  scs_printf("\n v is \n");
+  for (i = 0; i < l; i++) {
+    scs_printf("%f\n", w->v[i]);
+  }
+}
+
+void SCS(print_data)(const ScsData *d) {
+  scs_printf("m = %i\n", (int)d->m);
+  scs_printf("n = %i\n", (int)d->n);
+
+  scs_printf("max_iters = %i\n", (int)d->stgs->max_iters);
+  scs_printf("verbose = %i\n", (int)d->stgs->verbose);
+  scs_printf("normalize = %i\n", (int)d->stgs->normalize);
+  scs_printf("warm_start = %i\n", (int)d->stgs->warm_start);
+  scs_printf("acceleration_lookback = %i\n",
+             (int)d->stgs->acceleration_lookback);
+  scs_printf("eps = %4f\n", d->stgs->eps);
+  scs_printf("alpha = %4f\n", d->stgs->alpha);
+  scs_printf("rho_x = %4f\n", d->stgs->rho_x);
+  scs_printf("cg_rate = %4f\n", d->stgs->cg_rate);
+  scs_printf("scale = %4f\n", d->stgs->scale);
+  scs_printf("write_data_filename = %s\n",
+             (char *)d->stgs->write_data_filename);
+}
+
+void SCS(print_array)(const scs_float *arr, scs_int n, const char *name) {
+  scs_int i, j, k = 0;
+  scs_int num_on_one_line = 10;
+  scs_printf("\n");
+  for (i = 0; i < n / num_on_one_line; ++i) {
+    for (j = 0; j < num_on_one_line; ++j) {
+      scs_printf("%s[%li] = %4f, ", name, (long)k, arr[k]);
+      k++;
+    }
+    scs_printf("\n");
+  }
+  for (j = k; j < n; ++j) {
+    scs_printf("%s[%li] = %4f, ", name, (long)j, arr[j]);
+  }
+  scs_printf("\n");
+}
+
+void SCS(free_data)(ScsData *d, ScsCone *k) {
+  if (d) {
+    scs_free(d->b);
+    scs_free(d->c);
+    scs_free(d->stgs);
+    if (d->A) {
+      SCS(free_a_matrix)(d->A);
+    }
+    scs_free(d);
+  }
+  if (k) {
+    scs_free(k->q);
+    scs_free(k->s);
+    scs_free(k->p);
+    scs_free(k);
+  }
+}
+
+void SCS(free_sol)(ScsSolution *sol) {
+  if (sol) {
+    scs_free(sol->x);
+    scs_free(sol->y);
+    scs_free(sol->s);
+    scs_free(sol);
+  }
+}
+
+/* assumes d->stgs already allocated memory */
+void SCS(set_default_settings)(ScsData *d) {
+  /* These constants are defined in include/glbopts.h */
+  d->stgs->max_iters = MAX_ITERS;
+  d->stgs->eps = EPS;
+  d->stgs->alpha = ALPHA;
+  d->stgs->rho_x = RHO_X;
+  d->stgs->scale = SCALE;
+  d->stgs->cg_rate = CG_RATE;
+  d->stgs->verbose = VERBOSE;
+  d->stgs->normalize = NORMALIZE;
+  d->stgs->warm_start = WARM_START;
+  d->stgs->acceleration_lookback = ACCELERATION_LOOKBACK;
+  d->stgs->write_data_filename = WRITE_DATA_FILENAME;
+}

data/vendor/scs/test/minunit.h

@@ -0,0 +1,13 @@
+/* Taken from http://www.jera.com/techinfo/jtns/jtn002.html */
+
+/* Simple Macros for testing */
+#define mu_assert(message, test) \
+  do {                           \
+    if (!(test)) return message; \
+  } while (0)
+#define mu_run_test(test)         \
+  do {                            \
+    const char *message = test(); \
+    tests_run++;                  \
+    if (message) return message;  \
+  } while (0)

data/vendor/scs/test/problem_utils.h

@@ -0,0 +1,93 @@
+#ifndef PUTILS_H_GUARD
+#define PUTILS_H_GUARD
+
+#include "amatrix.h"
+#include "cones.h"
+#include "linalg.h"
+#include "scs.h"
+#include "util.h"
+
+#define PI (3.141592654)
+#ifdef DLONG
+#ifdef _WIN64
+/* this is a Microsoft extension, but also works with min_g_w-w64 */
+#define INTRW "%I64d"
+#else
+#define INTRW "%ld"
+#endif
+#else
+#define INTRW "%i"
+#endif
+
+void gen_random_prob_data(scs_int nnz, scs_int col_nnz, ScsData *d, ScsCone *k,
+                          ScsSolution *opt_sol);
+
+/* uniform random number in [-1,1] */
+static scs_float rand_scs_float(void) {
+  return 2 * (((scs_float)rand()) / RAND_MAX) - 1;
+}
+
+void gen_random_prob_data(scs_int nnz, scs_int col_nnz, ScsData *d, ScsCone *k,
+                          ScsSolution *opt_sol) {
+  scs_int n = d->n;
+  scs_int m = d->m;
+  ScsMatrix *A = d->A = (ScsMatrix *)scs_calloc(1, sizeof(ScsMatrix));
+  scs_float *b = d->b = (scs_float *)scs_calloc(m, sizeof(scs_float));
+  scs_float *c = d->c = (scs_float *)scs_calloc(n, sizeof(scs_float));
+  scs_float *x = opt_sol->x = (scs_float *)scs_calloc(n, sizeof(scs_float));
+  scs_float *y = opt_sol->y = (scs_float *)scs_calloc(m, sizeof(scs_float));
+  scs_float *s = opt_sol->s = (scs_float *)scs_calloc(m, sizeof(scs_float));
+  /* temporary variables */
+  scs_float *z = (scs_float *)scs_calloc(m, sizeof(scs_float));
+  scs_int i, j, r, rn, rm;
+
+  A->i = (scs_int *)scs_calloc(nnz, sizeof(scs_int));
+  A->p = (scs_int *)scs_calloc((n + 1), sizeof(scs_int));
+  A->x = (scs_float *)scs_calloc(nnz, sizeof(scs_float));
+  A->n = d->n;
+  A->m = d->m;
+  /* y, s >= 0 and y'*s = 0 */
+  for (i = 0; i < m; i++) {
+    y[i] = z[i] = rand_scs_float();
+  }
+
+  SCS(proj_dual_cone)(y, k, SCS_NULL, SCS_NULL, -1);
+
+  for (i = 0; i < m; i++) {
+    b[i] = s[i] = y[i] - z[i];
+  }
+
+  for (i = 0; i < n; i++) {
+    x[i] = rand_scs_float();
+  }
+
+  /*
+   c = -A'*y
+   b = A*x + s
+   */
+  A->p[0] = 0;
+  scs_printf("Generating random matrix:\n");
+  for (j = 0; j < n; j++) { /* column */
+    if (j * 100 % n == 0 && (j * 100 / n) % 10 == 0) {
+      scs_printf("%ld%%\n", (long)(j * 100 / n));
+    }
+    r = 0;
+    for (i = 0; i < m && r < col_nnz; ++i) {
+      /* generate a unique sorted array via Knuths alg */
+      rn = m - i;
+      rm = col_nnz - r;
+      if ((rand() % rn) < rm) {
+        A->x[r + j * col_nnz] = rand_scs_float();
+        A->i[r + j * col_nnz] = i;
+        b[i] += A->x[r + j * col_nnz] * x[j];
+        c[j] -= A->x[r + j * col_nnz] * y[i];
+        r++;
+      }
+    }
+    A->p[j + 1] = (j + 1) * col_nnz;
+  }
+  scs_printf("done\n");
+  scs_free(z);
+}
+
+#endif

data/vendor/scs/test/problems/rob_gauss_cov_est.h

@@ -0,0 +1,85 @@
+#include "amatrix.h"
+#include "glbopts.h"
+#include "linalg.h"
+#include "minunit.h"
+#include "scs.h"
+#include "util.h"
+
+static scs_float Ax[] = {-1.0, -0.25035003149, -0.214684983694, -0.0013696512491, -1.0, -1.0, 0.0941450010301, -0.0929840802212, 0.0143905024814, -1.0, -1.41421356237, -1.0, 0.0941450010301, -0.0929840802212, 0.0143905024814, 1.0, -1.0, -0.0354035554388, -0.0402731435884, -0.151196563215, -1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, 1.0, -1.0, 1.0, 1.0, -1.41421356237, 1.0, -1.41421356237, 1.0, -1.41421356237, 1.0, -1.0, 1.0, -1.41421356237, 1.0, -1.41421356237, 1.0, -1.0, 1.0, 1.0, -1.41421356237, 1.0, -1.0, -1.0, -1.0, 1.0, -1.0, -1.0, -1.0, -1.0, 1.0, -1.0, -1.0, 1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0};
+static scs_int Ai[] = {11, 15, 16, 17, 36, 12, 15, 16, 17, 18, 37, 13, 15, 16, 17, 18, 14, 15, 16, 17, 38, 15, 19, 16, 20, 17, 21, 19, 20, 21, 25, 19, 20, 21, 19, 22, 20, 23, 21, 24, 3, 26, 4, 5, 27, 7, 28, 9, 29, 6, 30, 8, 31, 10, 32, 11, 33, 12, 13, 34, 14, 35, 1, 7, 0, 8, 9, 2, 10, 1, 3, 41, 2, 6, 44, 25, 39, 25, 42};
+static scs_int Ap[] = {0, 5, 11, 16, 21, 23, 25, 27, 31, 34, 36, 38, 40, 42, 45, 47, 49, 51, 53, 55, 57, 60, 62, 64, 66, 67, 69, 72, 75, 77, 79};
+static scs_float b[] = {-0.0, -0.0, -0.0, -0.0, -0.0, -0.0, -0.0, -0.0, -0.0, -0.0, -0.0, -0.0, -0.0, -0.0, -0.0, -0.0, -0.0, -0.0, -0.0, -0.0, -0.0, -0.0, -0.0, -0.0, -0.0, -0.0, -0.0, -0.0, -0.0, -0.0, -0.0, -0.0, -0.0, -0.0, -0.0, -0.0, -0.0, -0.0, -0.0, -0.0, 1.0, -0.0, -0.0, 1.0, -0.0};
+static scs_float c[] ={0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
+
+static scs_int m = 45;
+static scs_int n = 30;
+
+static scs_int f = 19;
+static scs_int l = 7;
+static scs_int *q = SCS_NULL;
+static scs_int qsize = 0;
+static scs_int s[] = {4, 2};
+static scs_int ssize = 2;
+static scs_int ep = 2;
+static scs_int ed = 0;
+static scs_float *p = SCS_NULL;
+static scs_int psize = 0;
+
+static scs_float opt = -4.8912;
+
+static const char *rob_gauss_cov_est(void) {
+  ScsCone *k = (ScsCone *)scs_calloc(1, sizeof(ScsCone));
+  ScsData *d = (ScsData *)scs_calloc(1, sizeof(ScsData));
+  ScsSolution *sol = (ScsSolution *)scs_calloc(1, sizeof(ScsSolution));
+  ScsInfo info = {0};
+  scs_int exitflag;
+  scs_float perr, derr;
+  scs_int success;
+
+  d->m = m;
+  d->n = n;
+  d->b = b;
+  d->c = c;
+
+  d->stgs = (ScsSettings *)scs_calloc(1, sizeof(ScsSettings));
+  d->A = (ScsMatrix *)scs_calloc(1, sizeof(ScsMatrix));
+
+  d->A->m = m;
+  d->A->n = n;
+  d->A->x = Ax;
+  d->A->i = Ai;
+  d->A->p = Ap;
+
+  k->f = f;
+  k->l = l;
+  k->q = q;
+  k->qsize = qsize;
+  k->s = s;
+  k->ssize = ssize;
+  k->ep = ep;
+  k->ed = ed;
+  k->p = p;
+  k->psize = psize;
+
+  SCS(set_default_settings)(d);
+
+  exitflag = scs(d, k, sol, &info);
+
+  perr = SCS(dot)(d->c, sol->x, d->n) - opt;
+  derr = -SCS(dot)(d->b, sol->y, d->m) - opt;
+
+  scs_printf("primal obj error %4e\n", perr);
+  scs_printf("dual obj error %4e\n", derr);
+
+  success = ABS(perr) < 1e-4 && ABS(derr) < 1e-4 && exitflag == SCS_SOLVED;
+
+  SCS(free_sol)(sol);
+  scs_free(d->A);
+  scs_free(k);
+  scs_free(d->stgs);
+  scs_free(d);
+
+  mu_assert("rob_gauss_cov_est: SCS failed to produce outputflag SCS_SOLVED",
+            success);
+  return 0;
+}

data/vendor/scs/test/problems/small_lp.h

@@ -0,0 +1,50 @@
+#include "glbopts.h"
+#include "minunit.h"
+#include "problem_utils.h"
+#include "scs.h"
+#include "util.h"
+
+static const char *small_lp(void) {
+  ScsCone *k = (ScsCone *)scs_calloc(1, sizeof(ScsCone));
+  ScsData *d = (ScsData *)scs_calloc(1, sizeof(ScsData));
+  ScsSolution *sol = (ScsSolution *)scs_calloc(1, sizeof(ScsSolution));
+  ScsSolution *opt_sol = (ScsSolution *)scs_calloc(1, sizeof(ScsSolution));
+  ScsInfo info = {0};
+  scs_float p_f = 0.1;
+  int seed = 1234;
+  scs_int n = 100;
+  scs_int m = 300;
+  scs_int col_nnz = (scs_int)ceil(sqrt(n));
+  scs_int nnz = n * col_nnz;
+  scs_int exitflag;
+  scs_float perr, derr;
+  scs_int success;
+
+  d->stgs = (ScsSettings *)scs_calloc(1, sizeof(ScsSettings));
+  k->f = (scs_int)floor(m * p_f);
+  k->l = m - k->f;
+
+  srand(seed);
+
+  d->m = m;
+  d->n = n;
+  gen_random_prob_data(nnz, col_nnz, d, k, opt_sol);
+  SCS(set_default_settings)(d);
+
+  /* this test fails with the default choice of 10 */
+  d->stgs->acceleration_lookback = 20;
+
+  exitflag = scs(d, k, sol, &info);
+  perr = SCS(dot)(d->c, sol->x, d->n) - SCS(dot)(d->c, opt_sol->x, d->n);
+  derr = -SCS(dot)(d->b, sol->y, d->m) + SCS(dot)(d->b, opt_sol->y, d->m);
+  scs_printf("primal obj error %4e\n", perr);
+  scs_printf("dual obj error %4e\n", derr);
+
+  success = ABS(perr) < 1e-4 && ABS(derr) < 1e-4 && exitflag == SCS_SOLVED;
+
+  SCS(free_data)(d, k);
+  SCS(free_sol)(sol);
+  SCS(free_sol)(opt_sol);
+  mu_assert("small_lp: SCS failed to produce outputflag SCS_SOLVED", success);
+  return 0;
+}

data/vendor/scs/test/problems/small_random_socp.h

@@ -0,0 +1,33 @@
+#include "rw.h"
+#include "scs.h"
+#include "util.h"
+
+#define OPT (1.530897)
+
+static const char *small_random_socp(void) {
+  ScsData *d;
+  ScsCone *k;
+  ScsSolution *sol;
+  ScsInfo info = {0};
+  scs_int exitflag, success;
+  scs_float perr, derr;
+  const char *filename = "test/data/small_random_socp";
+
+  SCS(read_data)(filename, &d, &k);
+  sol = scs_calloc(1, sizeof(ScsSolution));
+  exitflag = scs(d, k, sol, &info);
+
+  perr = SCS(dot)(d->c, sol->x, d->n) - OPT;
+  derr = -SCS(dot)(d->b, sol->y, d->m) - OPT;
+
+  scs_printf("primal obj error %4e\n", perr);
+  scs_printf("dual obj error %4e\n", derr);
+
+  success = ABS(perr) < 1e-4 && ABS(derr) < 1e-4 && exitflag == SCS_SOLVED;
+
+  SCS(free_data)(d, k);
+  SCS(free_sol)(sol);
+  mu_assert("small_random_socp: SCS failed to produce outputflag SCS_SOLVED",
+            success);
+  return 0;
+}

data/vendor/scs/test/random_socp_prob.c

@@ -0,0 +1,171 @@
+#include <time.h> /* to seed random */
+#include "amatrix.h"
+#include "problem_utils.h"
+#include "scs.h"
+
+/*
+ create data for problem:
+
+ minimize 	    c'*x
+ subject to 	Ax <=_K b
+
+ where K is a product of zero, linear, and second-order cones. A is a sparse
+ matrix in
+ CSC format. A is 3n by n with about sqrt(n) nonzeros per column.
+
+ Construct data in such a way that the problem is primal and dual
+ feasible and thus bounded.
+ */
+
+int main(int argc, char **argv) {
+  scs_int n, m, col_nnz, nnz, i, q_total, q_num_rows, max_q;
+  ScsCone *k;
+  ScsData *d;
+  ScsSolution *sol, *opt_sol;
+  ScsInfo info = {0};
+  scs_float p_f, p_l;
+  int seed = 0;
+
+  /* default parameters */
+  p_f = 0.1;
+  p_l = 0.3;
+  seed = time(SCS_NULL);
+
+  switch (argc) {
+    case 5:
+      seed = atoi(argv[4]);
+    /* no break */
+    case 4:
+      p_f = atof(argv[2]);
+      p_l = atof(argv[3]);
+    /* no break */
+    case 2:
+      n = atoi(argv[1]);
+      break;
+    default:
+      scs_printf(
+          "usage:\t%s n p_f p_l s\n"
+          "\tcreates an SOCP with n variables where p_f fraction of "
+          "rows correspond\n"
+          "\tto equality constraints, p_l fraction of rows correspond "
+          "to LP constraints,\n"
+          "\tand the remaining percentage of rows are involved in "
+          "second-order\n"
+          "\tcone constraints. the random number generator is seeded "
+          "with s.\n"
+          "\tnote that p_f + p_l should be less than or equal to 1, "
+          "and that\n"
+          "\tp_f should be less than .33, since that corresponds to "
+          "as many equality\n"
+          "\tconstraints as variables.\n",
+          argv[0]);
+      scs_printf(
+          "\nusage:\t%s n p_f p_l\n"
+          "\tdefaults the seed to the system time\n",
+          argv[0]);
+      scs_printf(
+          "\nusage:\t%s n\n"
+          "\tdefaults to using p_f = 0.1 and p_l = 0.3\n",
+          argv[0]);
+      return 0;
+  }
+  srand(seed);
+  scs_printf("seed : %i\n", seed);
+
+  k = (ScsCone *)scs_calloc(1, sizeof(ScsCone));
+  d = (ScsData *)scs_calloc(1, sizeof(ScsData));
+  d->stgs = (ScsSettings *)scs_calloc(1, sizeof(ScsSettings));
+  sol = (ScsSolution *)scs_calloc(1, sizeof(ScsSolution));
+  opt_sol = (ScsSolution *)scs_calloc(1, sizeof(ScsSolution));
+
+  m = 3 * n;
+  col_nnz = (int)ceil(sqrt(n));
+  nnz = n * col_nnz;
+
+  max_q = (scs_int)ceil(3 * n / log(3 * n));
+
+  if (p_f + p_l > 1.0) {
+    printf("error: p_f + p_l > 1.0!\n");
+    return 1;
+  }
+
+  k->f = (scs_int)floor(3 * n * p_f);
+  k->l = (scs_int)floor(3 * n * p_l);
+
+  k->qsize = 0;
+  q_num_rows = 3 * n - k->f - k->l;
+  k->q = (scs_int *)scs_malloc(q_num_rows * sizeof(scs_int));
+
+  while (q_num_rows > max_q) {
+    int size;
+    size = (rand() % max_q) + 1;
+    k->q[k->qsize] = size;
+    k->qsize++;
+    q_num_rows -= size;
+  }
+  if (q_num_rows > 0) {
+    k->q[k->qsize] = q_num_rows;
+    k->qsize++;
+  }
+
+  q_total = 0;
+  for (i = 0; i < k->qsize; i++) {
+    q_total += k->q[i];
+  }
+
+  k->s = SCS_NULL;
+  k->ssize = 0;
+  k->ep = 0;
+  k->ed = 0;
+
+  scs_printf("\nA is %ld by %ld, with %ld nonzeros per column.\n", (long)m,
+             (long)n, (long)col_nnz);
+  scs_printf("A has %ld nonzeros (%f%% dense).\n", (long)nnz,
+             100 * (scs_float)col_nnz / m);
+  scs_printf("Nonzeros of A take %f GB of storage.\n",
+             ((scs_float)nnz * sizeof(scs_float)) / POWF(2, 30));
+  scs_printf("Row idxs of A take %f GB of storage.\n",
+             ((scs_float)nnz * sizeof(scs_int)) / POWF(2, 30));
+  scs_printf("Col ptrs of A take %f GB of storage.\n\n",
+             ((scs_float)n * sizeof(scs_int)) / POWF(2, 30));
+
+  printf("ScsCone information:\n");
+  printf("Zero cone rows: %ld\n", (long)k->f);
+  printf("LP cone rows: %ld\n", (long)k->l);
+  printf("Number of second-order cones: %ld, covering %ld rows, with sizes\n[",
+         (long)k->qsize, (long)q_total);
+  for (i = 0; i < k->qsize; i++) {
+    printf("%ld, ", (long)k->q[i]);
+  }
+  printf("]\n");
+  printf("Number of rows covered is %ld out of %ld.\n\n",
+         (long)(q_total + k->f + k->l), (long)m);
+
+  /* set up SCS structures */
+  d->m = m;
+  d->n = n;
+  gen_random_prob_data(nnz, col_nnz, d, k, opt_sol);
+  SCS(set_default_settings)(d);
+
+  /* d->stgs->write_data_filename = "random_socp_prob"; */
+
+  scs_printf("true pri opt = %4f\n", SCS(dot)(d->c, opt_sol->x, d->n));
+  scs_printf("true dua opt = %4f\n", -SCS(dot)(d->b, opt_sol->y, d->m));
+  /* solve! */
+  scs(d, k, sol, &info);
+  scs_printf("true pri opt = %4f\n", SCS(dot)(d->c, opt_sol->x, d->n));
+  scs_printf("true dua opt = %4f\n", -SCS(dot)(d->b, opt_sol->y, d->m));
+
+  if (sol->x) {
+    scs_printf("scs pri obj= %4f\n", SCS(dot)(d->c, sol->x, d->n));
+  }
+  if (sol->y) {
+    scs_printf("scs dua obj = %4f\n", -SCS(dot)(d->b, sol->y, d->m));
+  }
+
+  SCS(free_data)(d, k);
+  SCS(free_sol)(sol);
+  SCS(free_sol)(opt_sol);
+
+  return 0;
+}