scs 0.2.3 → 0.3.0

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

@@ -1,47 +1,141 @@
-#include "amatrix.h"
 #include "glbopts.h"
 #include "linalg.h"
 #include "minunit.h"
 #include "scs.h"
+#include "scs_matrix.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));
+  ScsSettings *stgs = (ScsSettings *)scs_calloc(1, sizeof(ScsSettings));
   ScsSolution *sol = (ScsSolution *)scs_calloc(1, sizeof(ScsSolution));
   ScsInfo info = {0};
   scs_int exitflag;
   scs_float perr, derr;
   scs_int success;
+  const char *fail;
+
+  /* data */
+  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};
+  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};
+  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};
+  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};
+  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};
+
+  scs_int m = 45;
+  scs_int n = 30;
+
+  scs_int z = 19;
+  scs_int l = 7;
+  scs_int *q = SCS_NULL;
+  scs_int qsize = 0;
+  scs_int s[] = {4, 2};
+  scs_int ssize = 2;
+  scs_int ep = 2;
+  scs_int ed = 0;
+  scs_float *p = SCS_NULL;
+  scs_int psize = 0;
+
+  scs_float opt = -4.8912;
+  /* end data */
 
   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;
@@ -50,7 +144,7 @@ static const char *rob_gauss_cov_est(void) {
   d->A->i = Ai;
   d->A->p = Ap;
 
-  k->f = f;
+  k->z = z;
   k->l = l;
   k->q = q;
   k->qsize = qsize;
@@ -61,9 +155,12 @@ static const char *rob_gauss_cov_est(void) {
   k->p = p;
   k->psize = psize;
 
-  SCS(set_default_settings)(d);
+  SCS(set_default_settings)(stgs);
+  stgs->eps_abs = 1e-6;
+  stgs->eps_rel = 1e-6;
+  stgs->eps_infeas = 1e-9;
 
-  exitflag = scs(d, k, sol, &info);
+  exitflag = scs(d, k, stgs, sol, &info);
 
   perr = SCS(dot)(d->c, sol->x, d->n) - opt;
   derr = -SCS(dot)(d->b, sol->y, d->m) - opt;
@@ -73,13 +170,73 @@ static const char *rob_gauss_cov_est(void) {
 
   success = ABS(perr) < 1e-4 && ABS(derr) < 1e-4 && exitflag == SCS_SOLVED;
 
-  SCS(free_sol)(sol);
+  mu_assert("rob_gauss_cov_est: SCS failed to produce outputflag SCS_SOLVED",
+            success);
+  fail = verify_solution_correct(d, k, stgs, &info, sol, exitflag);
+
+  /* test warm-starting */
+  stgs->warm_start = 1;
+  exitflag = scs(d, k, stgs, sol, &info);
+  /* 100 iters should be enough if warm-started */
+  mu_assert("rob_gauss_cov_est: warm-start failure", info.iter <= 100);
+  success = ABS(perr) < 1e-4 && ABS(derr) < 1e-4 && exitflag == SCS_SOLVED;
+
+  mu_assert("rob_gauss_cov_est: SCS failed to produce outputflag SCS_SOLVED",
+            success);
+
+  /* test read / write */
+  stgs->write_data_filename = "rob_gauss_cov_est";
+  stgs->max_iters = 1;
+
+  exitflag = scs(d, k, stgs, sol, &info);
+
+  /* kill data */
   scs_free(d->A);
   scs_free(k);
-  scs_free(d->stgs);
+  scs_free(stgs);
   scs_free(d);
 
-  mu_assert("rob_gauss_cov_est: SCS failed to produce outputflag SCS_SOLVED",
+  SCS(read_data)("rob_gauss_cov_est", &d, &k, &stgs);
+  stgs->max_iters = 1000;
+  /* solve with read data */
+  exitflag = scs(d, k, stgs, sol, &info);
+
+  perr = info.pobj - opt;
+  derr = info.dobj - 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;
+
+  mu_assert("rob_gauss_cov_est_rw: SCS failed to produce outputflag SCS_SOLVED",
             success);
-  return 0;
+  fail = verify_solution_correct(d, k, stgs, &info, sol, exitflag);
+
+  /* test other settings */
+  stgs->warm_start = 0;
+  stgs->normalize = 0;
+  stgs->adaptive_scale = 0;
+  stgs->acceleration_lookback = 10;
+  stgs->acceleration_interval = 10;
+  stgs->write_data_filename = SCS_NULL;
+  stgs->max_iters = 1000;
+  stgs->log_csv_filename = "rob_gauss_cov_est.csv";
+
+  exitflag = scs(d, k, stgs, sol, &info);
+
+  perr = info.pobj - opt;
+  derr = info.dobj - 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;
+
+  mu_assert("rob_gauss_cov_est_rw: SCS failed to produce outputflag SCS_SOLVED",
+            success);
+
+  SCS(free_sol)(sol);
+  SCS(free_data)(d, k, stgs);
+  return fail;
 }

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

@@ -7,6 +7,7 @@
 static const char *small_lp(void) {
   ScsCone *k = (ScsCone *)scs_calloc(1, sizeof(ScsCone));
   ScsData *d = (ScsData *)scs_calloc(1, sizeof(ScsData));
+  ScsSettings *stgs = (ScsSettings *)scs_calloc(1, sizeof(ScsSettings));
   ScsSolution *sol = (ScsSolution *)scs_calloc(1, sizeof(ScsSolution));
   ScsSolution *opt_sol = (ScsSolution *)scs_calloc(1, sizeof(ScsSolution));
   ScsInfo info = {0};
@@ -19,22 +20,19 @@ static const char *small_lp(void) {
   scs_int exitflag;
   scs_float perr, derr;
   scs_int success;
+  const char *fail;
 
-  d->stgs = (ScsSettings *)scs_calloc(1, sizeof(ScsSettings));
-  k->f = (scs_int)floor(m * p_f);
-  k->l = m - k->f;
-
-  srand(seed);
+  k->z = (scs_int)floor(m * p_f);
+  k->l = m - k->z;
 
   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;
+  gen_random_prob_data(nnz, col_nnz, d, k, opt_sol, seed);
+  SCS(set_default_settings)(stgs);
+  stgs->eps_abs = 1e-5;
+  stgs->eps_rel = 1e-5;
 
-  exitflag = scs(d, k, sol, &info);
+  exitflag = scs(d, k, stgs, 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);
@@ -42,9 +40,10 @@ static const char *small_lp(void) {
 
   success = ABS(perr) < 1e-4 && ABS(derr) < 1e-4 && exitflag == SCS_SOLVED;
 
-  SCS(free_data)(d, k);
+  mu_assert("small_lp: SCS failed to produce outputflag SCS_SOLVED", success);
+  fail = verify_solution_correct(d, k, stgs, &info, sol, exitflag);
+  SCS(free_data)(d, k, stgs);
   SCS(free_sol)(sol);
   SCS(free_sol)(opt_sol);
-  mu_assert("small_lp: SCS failed to produce outputflag SCS_SOLVED", success);
-  return 0;
+  return fail;
 }

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

@@ -0,0 +1,43 @@
+#include "glbopts.h"
+#include "minunit.h"
+#include "problem_utils.h"
+#include "scs.h"
+#include "util.h"
+
+static const char *test_fails(void) {
+  scs_printf("Testing that SCS handles bad inputs correctly:");
+
+  ScsCone *k = (ScsCone *)scs_calloc(1, sizeof(ScsCone));
+  ScsData *d = (ScsData *)scs_calloc(1, sizeof(ScsData));
+  ScsSettings *stgs = (ScsSettings *)scs_calloc(1, sizeof(ScsSettings));
+  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 = 1;
+  scs_int m = 3;
+  scs_int col_nnz = (scs_int)ceil(sqrt(n));
+  scs_int nnz = n * col_nnz;
+  scs_int exitflag;
+
+  k->z = (scs_int)floor(m * p_f);
+  k->l = m - k->z;
+
+  d->m = m;
+  d->n = n;
+  gen_random_prob_data(nnz, col_nnz, d, k, opt_sol, seed);
+  SCS(set_default_settings)(stgs);
+
+  /* TODO test more failure modes */
+  stgs->eps_abs = -1;
+
+  exitflag = scs(d, k, stgs, sol, &info);
+
+  mu_assert("test_fails: SCS failed to produce outputflag SCS_FAILED",
+            exitflag == SCS_FAILED);
+  SCS(free_data)(d, k, stgs);
+  SCS(free_sol)(sol);
+  SCS(free_sol)(opt_sol);
+  return 0;
+}

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

@@ -0,0 +1,82 @@
+#include "glbopts.h"
+#include "linalg.h"
+#include "minunit.h"
+#include "scs.h"
+#include "scs_matrix.h"
+#include "util.h"
+
+static const char *unbounded_tiny_qp(void) {
+  ScsCone *k = (ScsCone *)scs_calloc(1, sizeof(ScsCone));
+  ScsData *d = (ScsData *)scs_calloc(1, sizeof(ScsData));
+  ScsSettings *stgs = (ScsSettings *)scs_calloc(1, sizeof(ScsSettings));
+  ScsSolution *sol = (ScsSolution *)scs_calloc(1, sizeof(ScsSolution));
+  ScsInfo info = {0};
+  scs_int exitflag;
+  const char *fail;
+
+  /* data */
+  scs_float Ax[] = {
+      -0.04101197, 1.68314201,  0.5543439,   -0.96712378, 0.19370457,
+      -1.15055711, 1.13315795,  -1.05910693, 1.24512977,  -0.70999048,
+      -0.89976326, -0.41373294, -0.73848186, 0.08663554,  -0.1681749,
+      -0.42711619, -0.90501247, -0.490446,   -0.67124734, 1.67772257,
+      0.39924394,  0.16330292,  0.55609205,  -1.22088238, -0.25891675,
+      -3.07159984, -1.84102417, 1.5621635,   -1.13771529, 0.56067264,
+      -0.0854747,  0.31024722,  -0.07437118, -0.20711534, -0.35241366,
+      -0.98965142, -1.91488894, 1.01591507,  0.45387459,  1.43709968,
+      -0.0482982,  -0.32447,    -0.91433399, 0.49750765,  0.09150015,
+      0.69164184,  0.51064936,  -1.35009809, -1.35403213, 1.51897627};
+  scs_int Ai[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6,
+                  7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3,
+                  4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+  scs_int Ap[] = {0, 10, 20, 30, 40, 50};
+
+  scs_float b[] = {1.4672744,   0.36190605, -0.5548082,  -0.35039932,
+                   -1.12765224, 0.51012137, -0.24927975, -1.45270362,
+                   -1.94080389, -0.0189713};
+  scs_float c[] = {0.17547329, -0.11983635, -0.11791039, 0.12099476,
+                   0.61931906};
+
+  scs_int m = 10;
+  scs_int n = 5;
+
+  scs_int l = m;
+
+  /* end data */
+
+  d->m = m;
+  d->n = n;
+  d->b = b;
+  d->c = c;
+
+  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->l = l;
+
+  SCS(set_default_settings)(stgs);
+  stgs->eps_abs = 1e-6;
+  stgs->eps_rel = 1e-6;
+  stgs->eps_infeas = 1e-7;
+
+  exitflag = scs(d, k, stgs, sol, &info);
+
+  mu_assert("unbounded_tiny_qp: SCS failed to produce outputflag SCS_UNBOUNDED",
+            exitflag == SCS_UNBOUNDED);
+
+  fail = verify_solution_correct(d, k, stgs, &info, sol, exitflag);
+
+  SCS(free_sol)(sol);
+  scs_free(d->A);
+  scs_free(d->P);
+  scs_free(k);
+  scs_free(stgs);
+  scs_free(d);
+  return fail;
+}

data/vendor/scs/test/random_socp_prob.c

@@ -1,7 +1,7 @@
-#include <time.h> /* to seed random */
-#include "amatrix.h"
 #include "problem_utils.h"
 #include "scs.h"
+#include "scs_matrix.h"
+#include <time.h> /* to seed random */
 
 /*
  create data for problem:
@@ -11,7 +11,7 @@
 
  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.
+ CSC format. A is factor * n 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.
@@ -21,9 +21,11 @@ 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;
+  ScsSettings *stgs;
   ScsSolution *sol, *opt_sol;
   ScsInfo info = {0};
   scs_float p_f, p_l;
+  scs_int factor = 4;
   int seed = 0;
 
   /* default parameters */
@@ -32,68 +34,64 @@ int main(int argc, char **argv) {
   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;
+  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));
+  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;
+  m = factor * n;
   col_nnz = (int)ceil(sqrt(n));
   nnz = n * col_nnz;
 
-  max_q = (scs_int)ceil(3 * n / log(3 * n));
+  max_q = (scs_int)ceil(factor * n / log(factor * 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->z = (scs_int)floor(factor * n * p_f);
+  k->l = (scs_int)floor(factor * n * p_l);
 
   k->qsize = 0;
-  q_num_rows = 3 * n - k->f - k->l;
+  q_num_rows = factor * n - k->z - k->l;
   k->q = (scs_int *)scs_malloc(q_num_rows * sizeof(scs_int));
 
   while (q_num_rows > max_q) {
@@ -117,6 +115,9 @@ int main(int argc, char **argv) {
   k->ssize = 0;
   k->ep = 0;
   k->ed = 0;
+  k->bsize = 0;
+  k->bu = SCS_NULL;
+  k->bl = SCS_NULL;
 
   scs_printf("\nA is %ld by %ld, with %ld nonzeros per column.\n", (long)m,
              (long)n, (long)col_nnz);
@@ -130,7 +131,7 @@ int main(int argc, char **argv) {
              ((scs_float)n * sizeof(scs_int)) / POWF(2, 30));
 
   printf("ScsCone information:\n");
-  printf("Zero cone rows: %ld\n", (long)k->f);
+  printf("Zero cone rows: %ld\n", (long)k->z);
   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);
@@ -139,20 +140,20 @@ int main(int argc, char **argv) {
   }
   printf("]\n");
   printf("Number of rows covered is %ld out of %ld.\n\n",
-         (long)(q_total + k->f + k->l), (long)m);
+         (long)(q_total + k->z + 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);
+  gen_random_prob_data(nnz, col_nnz, d, k, opt_sol, seed);
+  SCS(set_default_settings)(stgs);
 
-  /* d->stgs->write_data_filename = "random_socp_prob"; */
+  /* 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(d, k, stgs, 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));
 
@@ -163,7 +164,7 @@ int main(int argc, char **argv) {
     scs_printf("scs dua obj = %4f\n", -SCS(dot)(d->b, sol->y, d->m));
   }
 
-  SCS(free_data)(d, k);
+  SCS(free_data)(d, k, stgs);
   SCS(free_sol)(sol);
   SCS(free_sol)(opt_sol);