scs 0.3.2 → 0.4.1

data/vendor/scs/src/util.c

@@ -5,7 +5,7 @@
 #include "scs_matrix.h"
 
 /* return milli-seconds */
-#if (defined NOTIMER)
+#if (defined NO_TIMER)
 
 void SCS(tic)(SCS(timer) * t) {
 }
@@ -71,7 +71,41 @@ scs_float SCS(tocq)(SCS(timer) * t) {
 
 #endif
 
-void SCS(free_data)(ScsData *d, ScsCone *k, ScsSettings *stgs) {
+void SCS(deep_copy_data)(ScsData *dest, const ScsData *src) {
+  dest->n = src->n;
+  dest->m = src->m;
+  SCS(copy_matrix)(&(dest->A), src->A);
+  SCS(copy_matrix)(&(dest->P), src->P);
+  dest->b = (scs_float *)scs_calloc(dest->m, sizeof(scs_float));
+  memcpy(dest->b, src->b, dest->m * sizeof(scs_float));
+  dest->c = (scs_float *)scs_calloc(dest->n, sizeof(scs_float));
+  memcpy(dest->c, src->c, dest->n * sizeof(scs_float));
+}
+
+void SCS(deep_copy_stgs)(ScsSettings *dest, const ScsSettings *src) {
+  memcpy(dest, src, sizeof(ScsSettings));
+  /* MATLAB does something weird with strdup, so use strcpy instead */
+  char *tmp;
+  if (src->write_data_filename) {
+    /* sizeof(char) = 1 */
+    tmp = (char *)scs_malloc(strlen(src->write_data_filename) + 1);
+    strcpy(tmp, src->write_data_filename);
+    dest->write_data_filename = tmp;
+  } else {
+    dest->write_data_filename = SCS_NULL;
+  }
+  /* MATLAB does something weird with strdup, so use strcpy instead */
+  if (src->log_csv_filename) {
+    /* sizeof(char) = 1 */
+    tmp = (char *)scs_malloc(strlen(src->log_csv_filename) + 1);
+    strcpy(tmp, src->log_csv_filename);
+    dest->log_csv_filename = tmp;
+  } else {
+    dest->log_csv_filename = SCS_NULL;
+  }
+}
+
+void SCS(free_data)(ScsData *d) {
   if (d) {
     scs_free(d->b);
     scs_free(d->c);
@@ -83,17 +117,6 @@ void SCS(free_data)(ScsData *d, ScsCone *k, ScsSettings *stgs) {
     }
     scs_free(d);
   }
-  if (k) {
-    scs_free(k->bu);
-    scs_free(k->bl);
-    scs_free(k->q);
-    scs_free(k->s);
-    scs_free(k->p);
-    scs_free(k);
-  }
-  if (stgs) {
-    scs_free(stgs);
-  }
 }
 
 void SCS(free_sol)(ScsSolution *sol) {

data/vendor/scs/test/minunit.h

@@ -8,11 +8,13 @@
       return message;                                                          \
     }                                                                          \
   } while (0)
+
 #define mu_assert(message, test)                                               \
   do {                                                                         \
     if (!(test))                                                               \
       return message;                                                          \
   } while (0)
+
 #define mu_run_test(test) _mu_run_test(#test, test)
 
 #define _mu_run_test(name, test)                                               \
@@ -21,7 +23,6 @@
     scs_printf("Running test: %s\n", name);                                    \
     const char *message = test();                                              \
     tests_run++;                                                               \
-    scs_printf("*********************************************************\n"); \
     if (message)                                                               \
       return message;                                                          \
   } while (0)

data/vendor/scs/test/problem_utils.h

@@ -190,6 +190,7 @@ const char *verify_solution_correct(ScsData *d, ScsCone *k, ScsSettings *stgs,
 
   /************** OPTIMALITY ****************/
 
+  /* TODO: the MAX expansion computes these norms many times */
   grl = MAX(MAX(ABS(xt_p_x), ABS(ctx)), ABS(bty));
   prl = MAX(MAX(NORM(b, m), NORM(s, m)), NORM(ax, m));
   drl = MAX(MAX(NORM(c, n), NORM(px, n)), NORM(aty, n));
@@ -205,17 +206,17 @@ const char *verify_solution_correct(ScsData *d, ScsCone *k, ScsSettings *stgs,
   /**************** ASSERTS *****************/
   if (status == SCS_SOLVED) {
     mu_assert_less("Primal residual ERROR", ABS(res_pri - info->res_pri),
-                   1e-11);
+                   1e-10);
     mu_assert_less("Dual residual ERROR", ABS(res_dual - info->res_dual),
-                   1e-11);
-    mu_assert_less("Gap ERROR", ABS(gap - info->gap), 1e-8 * (1 + ABS(gap)));
+                   1e-10);
+    mu_assert_less("Gap ERROR", ABS(gap - info->gap), 1e-7 * (1 + ABS(gap)));
     mu_assert_less("Primal obj ERROR", ABS(pobj - info->pobj),
                    1e-9 * (1 + ABS(pobj)));
     mu_assert_less("Dual obj ERROR", ABS(dobj - info->dobj),
                    1e-9 * (1 + ABS(dobj)));
     /* slightly looser tol */
     mu_assert_less("Complementary slackness ERROR", ABS(sty),
-                   1e-8 * MAX(NORM(s, m), NORM(y, m)));
+                   5e-8 * MAX(NORM(s, m), NORM(y, m)));
     mu_assert_less("s cone dist ERROR", ABS(sdist), 1e-5);
     mu_assert_less("y cone dist ERROR", ABS(ydist), 1e-5);
 

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

@@ -1,6 +1,7 @@
 #include "glbopts.h"
 #include "linalg.h"
 #include "minunit.h"
+#include "problem_utils.h"
 #include "scs.h"
 #include "scs_matrix.h"
 #include "util.h"

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

@@ -1,6 +1,7 @@
 #include "glbopts.h"
 #include "linalg.h"
 #include "minunit.h"
+#include "problem_utils.h"
 #include "scs.h"
 #include "scs_matrix.h"
 #include "util.h"
@@ -67,7 +68,7 @@ static const char *hs21_tiny_qp(void) {
   scs_set_default_settings(stgs);
   stgs->eps_abs = 1e-6;
   stgs->eps_rel = 1e-6;
-  stgs->eps_infeas = 1e-9;
+  stgs->eps_infeas = 0.; /* disable due to gpu test finding cert */
 
   exitflag = scs(d, k, stgs, sol, &info);
 

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

@@ -1,6 +1,7 @@
 #include "glbopts.h"
 #include "linalg.h"
 #include "minunit.h"
+#include "problem_utils.h"
 #include "rw.h"
 #include "scs.h"
 #include "scs_matrix.h"
@@ -15,7 +16,7 @@ static const char *hs21_tiny_qp_rw(void) {
   ScsInfo info = {0};
   scs_int exitflag;
   scs_float perr, derr;
-  scs_int success;
+  scs_int success, read_status;
   const char *fail;
 
   /* data */
@@ -69,7 +70,7 @@ static const char *hs21_tiny_qp_rw(void) {
   scs_set_default_settings(stgs);
   stgs->eps_abs = 1e-6;
   stgs->eps_rel = 1e-6;
-  stgs->eps_infeas = 1e-9;
+  stgs->eps_infeas = 0.; /* disable due to gpu test finding cert */
 
   stgs->write_data_filename = "hs21_tiny_qp";
   stgs->max_iters = 1;
@@ -83,7 +84,12 @@ static const char *hs21_tiny_qp_rw(void) {
   scs_free(stgs);
   scs_free(d);
 
-  SCS(read_data)("hs21_tiny_qp", &d, &k, &stgs);
+  read_status = SCS(read_data)("hs21_tiny_qp", &d, &k, &stgs);
+
+  if (read_status < 0) {
+    return "Data read failure, exit.\n";
+  }
+
   stgs->max_iters = 1000;
   /* solve with read data */
   exitflag = scs(d, k, stgs, sol, &info);
@@ -110,7 +116,10 @@ static const char *hs21_tiny_qp_rw(void) {
   mu_assert("hs21_tiny_qp: SCS failed to produce outputflag SCS_SOLVED",
             success);
 
+  SCS(free_data)(d);
+  SCS(free_cone)(k);
   SCS(free_sol)(sol);
-  SCS(free_data)(d, k, stgs);
+  scs_free(stgs);
+
   return fail;
 }

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

@@ -1,6 +1,7 @@
 #include "glbopts.h"
 #include "linalg.h"
 #include "minunit.h"
+#include "problem_utils.h"
 #include "scs.h"
 #include "scs_matrix.h"
 #include "util.h"

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

@@ -0,0 +1,8 @@
+#include "glbopts.h"
+#include "problems/test_prob_from_data_file.h"
+#include "scs.h"
+
+static const char *max_ent(void) {
+  scs_float OPT = -6.067087663361563; /* from ecos */
+  return _test_prob_from_data("test/problems/max_ent", OPT);
+}

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

@@ -1,6 +1,7 @@
 #include "glbopts.h"
 #include "linalg.h"
 #include "minunit.h"
+#include "problem_utils.h"
 #include "scs.h"
 #include "scs_matrix.h"
 #include "util.h"
@@ -141,7 +142,7 @@ static const char *qafiro_tiny_qp(void) {
   stgs->warm_start = 1;
   exitflag = scs(d, k, stgs, sol, &info);
   /* 25 iters should be enough if warm-started */
-  mu_assert("qafiro_tiny_qp: warm-start failure", info.iter <= 50);
+  mu_assert("qafiro_tiny_qp: warm-start failure", info.iter <= 100);
   success = ABS(perr) < 1e-4 && ABS(derr) < 1e-4 && exitflag == SCS_SOLVED;
 
   mu_assert("qafiro_tiny_qp: SCS failed to produce outputflag SCS_SOLVED",

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

@@ -1,45 +1,8 @@
 #include "glbopts.h"
-#include "minunit.h"
-#include "problem_utils.h"
+#include "problems/test_prob_from_data_file.h"
 #include "scs.h"
-#include "util.h"
 
 static const char *random_prob(void) {
-  scs_int read_status;
-  ScsData *d;
-  ScsCone *k;
-  ScsSettings *stgs;
-  ScsSolution *sol;
-  ScsInfo info = {0};
-  scs_int exitflag;
-  scs_float perr, derr;
-  scs_int success;
-  const char *fail;
-
   scs_float OPT = 5.751458006385587;
-
-  read_status = SCS(read_data)("test/problems/random_prob", &d, &k, &stgs);
-
-  if (read_status < 0) {
-    return "Data read failure, exit.\n";
-  }
-
-  stgs->eps_abs = 1e-6;
-  stgs->eps_rel = 1e-6;
-
-  sol = (ScsSolution *)scs_calloc(1, sizeof(ScsSolution));
-  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;
-  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("random_prob: SCS failed to produce SCS_SOLVED", success);
-  fail = verify_solution_correct(d, k, stgs, &info, sol, exitflag);
-  SCS(free_data)(d, k, stgs);
-  SCS(free_sol)(sol);
-  return fail;
+  return _test_prob_from_data("test/problems/random_prob", OPT);
 }

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

@@ -1,6 +1,8 @@
 #include "glbopts.h"
 #include "linalg.h"
 #include "minunit.h"
+#include "problem_utils.h"
+#include "rw.h"
 #include "scs.h"
 #include "scs_matrix.h"
 #include "util.h"
@@ -13,7 +15,7 @@ static const char *rob_gauss_cov_est(void) {
   ScsInfo info = {0};
   scs_int exitflag;
   scs_float perr, derr;
-  scs_int success;
+  scs_int success, read_status;
   const char *fail;
 
   /* data */
@@ -173,6 +175,8 @@ static const char *rob_gauss_cov_est(void) {
   mu_assert("rob_gauss_cov_est: SCS failed to produce outputflag SCS_SOLVED",
             success);
   fail = verify_solution_correct(d, k, stgs, &info, sol, exitflag);
+  if (fail)
+    return fail;
 
   /* test warm-starting */
   stgs->warm_start = 1;
@@ -196,7 +200,12 @@ static const char *rob_gauss_cov_est(void) {
   scs_free(stgs);
   scs_free(d);
 
-  SCS(read_data)("rob_gauss_cov_est", &d, &k, &stgs);
+  read_status = SCS(read_data)("rob_gauss_cov_est", &d, &k, &stgs);
+
+  if (read_status < 0) {
+    return "Data read failure, exit.\n";
+  }
+
   stgs->max_iters = 1000;
   /* solve with read data */
   exitflag = scs(d, k, stgs, sol, &info);
@@ -236,7 +245,10 @@ static const char *rob_gauss_cov_est(void) {
   mu_assert("rob_gauss_cov_est_rw: SCS failed to produce outputflag SCS_SOLVED",
             success);
 
+  SCS(free_data)(d);
+  SCS(free_cone)(k);
   SCS(free_sol)(sol);
-  SCS(free_data)(d, k, stgs);
+  scs_free(stgs);
+
   return fail;
 }

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

@@ -44,8 +44,11 @@ static const char *small_lp(void) {
 
   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_data)(d);
+  SCS(free_cone)(k);
   SCS(free_sol)(sol);
   SCS(free_sol)(opt_sol);
+  scs_free(stgs);
+
   return fail;
 }

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

@@ -251,7 +251,7 @@ scs_float u[] = {
     96.00000, 96.00000,  96.00000,   96.00000,  96.00000,  96.00000,
     96.00000, 96.00000,  96.00000,   96.00000,  96.00000,  96.00000,
     96.00000, 96.00000,  96.00000,   96.00000};
-scs_float q[] = {0.00000,     0.00000,    -35.02643,   0.00000,     0.00000,
+scs_float c[] = {0.00000,     0.00000,    -35.02643,   0.00000,     0.00000,
                  -3.56718,    0.00000,    -17.41907,   0.00000,     0.00000,
                  -17.64691,   0.00000,    0.00000,     0.00000,     0.00000,
                  0.00000,     0.00000,    0.00000,     0.00000,     0.00000,
@@ -298,7 +298,7 @@ static const char *small_qp(void) {
   d->n = n;
   d->b = (scs_float *)scs_calloc(m + 1, sizeof(scs_float));
   d->b[0] = 1; /* t var in box cone */
-  d->c = q;
+  d->c = c;
 
   d->A = (ScsMatrix *)scs_calloc(1, sizeof(ScsMatrix));
   d->A->m = m + 1; /* t var in box cone */
@@ -332,11 +332,48 @@ static const char *small_qp(void) {
   stgs->eps_rel = 1e-6;
   stgs->eps_infeas = 1e-10;
 
-  exitflag = scs(d, k, stgs, sol, &info);
+  ScsWork *w = scs_init(d, k, stgs);
+  exitflag = scs_solve(w, sol, &info, 0);
   success = exitflag == SCS_SOLVED;
 
   mu_assert("small_qp: SCS failed to produce outputflag SCS_SOLVED", success);
   fail = verify_solution_correct(d, k, stgs, &info, sol, exitflag);
+  if (fail)
+    return fail;
+
+  /* test updating c */
+  d->c[0] = 1.0; /* set to new value */
+  scs_update(w, SCS_NULL, d->c);
+  exitflag = scs_solve(w, sol, &info, 1);
+  success = exitflag == SCS_SOLVED;
+
+  mu_assert("small_qp: SCS failed to produce outputflag SCS_SOLVED", success);
+  fail = verify_solution_correct(d, k, stgs, &info, sol, exitflag);
+  if (fail)
+    return fail;
+
+  /* test updating b */
+  d->b[0] = 4.0; /* set to new value */
+  scs_update(w, d->b, SCS_NULL);
+  exitflag = scs_solve(w, sol, &info, 1);
+  success = exitflag == SCS_SOLVED;
+
+  mu_assert("small_qp: SCS failed to produce outputflag SCS_SOLVED", success);
+  fail = verify_solution_correct(d, k, stgs, &info, sol, exitflag);
+  if (fail)
+    return fail;
+
+  /* revert back to original data */
+  d->c[0] = 0.0; /* revert to original value */
+  d->b[0] = 1.0; /* revert to original value */
+  scs_update(w, d->b, d->c);
+  exitflag = scs_solve(w, sol, &info, 1);
+  success = exitflag == SCS_SOLVED;
+
+  mu_assert("small_qp: SCS failed to produce outputflag SCS_SOLVED", success);
+  fail = verify_solution_correct(d, k, stgs, &info, sol, exitflag);
+
+  scs_finish(w);
 
   scs_free(d->A);
   scs_free(d->P);
@@ -344,9 +381,7 @@ static const char *small_qp(void) {
   scs_free(k);
   scs_free(d);
   scs_free(stgs);
-  scs_free(sol->x);
-  scs_free(sol->y);
-  scs_free(sol->s);
-  scs_free(sol);
+  SCS(free_sol)(sol);
+
   return fail;
 }

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

@@ -0,0 +1,84 @@
+#include "glbopts.h"
+#include "linalg.h"
+#include "minunit.h"
+#include "scs.h"
+
+/* Forward declare exponential cone projection routine.
+ * Implemented in exp_cone.c.
+ */
+scs_float SCS(proj_pd_exp_cone)(scs_float *v0, scs_int primal);
+
+static scs_int _run_exp_cone_test(scs_float *v0, scs_float *vp_true,
+                                  scs_float *vd_true) {
+  scs_int success = 1;
+  scs_float vp[3], vd[3];
+  const scs_float TOL = 1e-6;
+
+  memcpy(vp, v0, 3 * sizeof(scs_float));
+  memcpy(vd, v0, 3 * sizeof(scs_float));
+
+  /* inefficient, but just for testing */
+  SCS(proj_pd_exp_cone)(vp, 1);
+  SCS(proj_pd_exp_cone)(vd, 0);
+
+  scs_printf("*******************************\n");
+  scs_printf("v0: (%f, %f, %f)\n", v0[0], v0[1], v0[2]);
+  scs_printf("vp: (%f, %f, %f)\n", vp[0], vp[1], vp[2]);
+  scs_printf("vp_true: (%f, %f, %f)\n", vp_true[0], vp_true[1], vp_true[2]);
+  scs_printf("vd: (%f, %f, %f)\n", vd[0], vd[1], vd[2]);
+  scs_printf("vd_true: (%f, %f, %f)\n", vd_true[0], vd_true[1], vd_true[2]);
+
+  success &= (SCS(norm_diff)(vp, vp_true, 3) <= TOL);
+  success &= (SCS(norm_diff)(vd, vd_true, 3) <= TOL);
+  /* Moreau decomposition holds only for polar */
+  /*
+  success &= (SCS(dot)(vp, vd, 3) <= TOL);
+  success &= (ABS(v0[0] - vp[0] + vd[0]) <= TOL);
+  success &= (ABS(v0[1] - vp[1] + vd[1]) <= TOL);
+  success &= (ABS(v0[2] - vp[2] + vd[2]) <= TOL);
+  */
+
+  if (!success) {
+    scs_printf("Failed.\n");
+  }
+
+  return success;
+}
+
+static const char *test_exp_cone(void) {
+  scs_int success = 1;
+  scs_int i;
+  /* test points */
+  scs_float v0[6][3] = {
+      {1, 2, 3},
+      {0.14814832, 1.04294573, 0.67905585},
+      {-0.78301134, 1.82790084, -1.05417044},
+      {1.3282585, -0.43277314, 1.7468072},
+      {0.67905585, 0.14814832, 1.04294573},
+      {0.50210027, 0.12314491, -1.77568921},
+  };
+  /* primal projections */
+  scs_float vp[6][3] = {
+      {0.8899428, 1.94041881, 3.06957226},
+      {-0.02001571, 0.8709169, 0.85112944},
+      {-1.17415616, 0.9567094, 0.280399},
+      {0.53160512, 0.2804836, 1.86652094},
+      {0.38322814, 0.27086569, 1.11482228},
+      {0., 0., 0.},
+  };
+  /* dual projections */
+  scs_float vd[6][3] = {
+      {-0., 2., 3.},
+      {-0., 1.04294573, 0.67905585},
+      {-0.68541419, 1.85424082, 0.01685653},
+      {-0.02277033, -0.12164823, 1.75085347},
+      {-0., 0.14814832, 1.04294573},
+      {-0., 0.12314491, -0.},
+  };
+
+  for (i = 0; i < 6; ++i) {
+    success &= _run_exp_cone_test(v0[i], vp[i], vd[i]);
+  }
+  mu_assert("test_exp_cone: Failure", success);
+  return 0;
+}

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

@@ -0,0 +1,57 @@
+#ifndef _SCS_FILE_TEST_CHASSIS
+#define _SCS_FILE_TEST_CHASSIS
+
+#include "glbopts.h"
+#include "minunit.h"
+#include "problem_utils.h"
+#include "rw.h"
+#include "scs.h"
+#include "util.h"
+
+static const char *_test_prob_from_data(const char *file, scs_float OPT) {
+  scs_int read_status;
+  ScsData *d;
+  ScsCone *k;
+  ScsSettings *stgs;
+  ScsSolution *sol;
+  ScsInfo info = {0};
+  scs_int exitflag;
+  scs_float perr, derr;
+  scs_int success;
+  const char *fail;
+
+  read_status = SCS(read_data)(file, &d, &k, &stgs);
+
+  if (read_status < 0) {
+    return "Data read failure, exit.\n";
+  }
+
+  stgs->eps_abs = 1e-6;
+  stgs->eps_rel = 1e-6;
+
+  sol = (ScsSolution *)scs_calloc(1, sizeof(ScsSolution));
+  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;
+  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;
+  if (!success) {
+    scs_printf("%s: FAILED\n", file);
+  }
+  mu_assert(file, success);
+  fail = verify_solution_correct(d, k, stgs, &info, sol, exitflag);
+  SCS(free_data)(d);
+  SCS(free_cone)(k);
+  SCS(free_sol)(sol);
+  scs_free(stgs);
+
+  if (fail) {
+    scs_printf("%s: FAILED\n", file);
+  }
+  return fail;
+}
+
+#endif

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

@@ -36,8 +36,11 @@ static const char *test_validation(void) {
 
   mu_assert("test_fails: SCS failed to produce outputflag SCS_FAILED",
             exitflag == SCS_FAILED);
-  SCS(free_data)(d, k, stgs);
+  SCS(free_data)(d);
+  SCS(free_cone)(k);
   SCS(free_sol)(sol);
   SCS(free_sol)(opt_sol);
+  scs_free(stgs);
+
   return 0;
 }

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

@@ -1,6 +1,7 @@
 #include "glbopts.h"
 #include "linalg.h"
 #include "minunit.h"
+#include "problem_utils.h"
 #include "scs.h"
 #include "scs_matrix.h"
 #include "util.h"
@@ -73,10 +74,9 @@ static const char *unbounded_tiny_qp(void) {
   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_cone)(k);
   scs_free(stgs);
+  scs_free(d->A);
   scs_free(d);
   return fail;
 }

data/vendor/scs/test/random_socp_prob.c

@@ -164,9 +164,11 @@ 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, stgs);
+  SCS(free_data)(d);
+  SCS(free_cone)(k);
   SCS(free_sol)(sol);
   SCS(free_sol)(opt_sol);
+  scs_free(stgs);
 
   return 0;
 }

data/vendor/scs/test/run_from_file.c

@@ -60,19 +60,37 @@ int main(int argc, char **argv) {
   }
   for (i = 2; i < argc; i += 2) {
     if (argc < i + 2) {
-      scs_printf("Incorrect number of arguments supplied\n.");
-      SCS(free_data)(d, k, stgs);
+      scs_printf("Incorrect number of arguments supplied.\n");
+
+      SCS(free_data)(d);
+      SCS(free_cone)(k);
+      scs_free(stgs);
+
       return -1;
     }
     if (override_setting(stgs, argv[i], argv[i + 1]) < 0) {
       scs_printf("Unrecognized setting %s\n", argv[i]);
-      SCS(free_data)(d, k, stgs);
+
+      SCS(free_data)(d);
+      SCS(free_cone)(k);
+      scs_free(stgs);
+
       return -1;
     }
   }
+  if (!stgs->verbose) {
+    scs_printf(
+        "File data set `verbose` to 0, SCS will not output information. Add "
+        "`verbose 1` to call to override.\n");
+  }
+  scs_printf("Solving problem.\n");
   sol = (ScsSolution *)scs_calloc(1, sizeof(ScsSolution));
   scs(d, k, stgs, sol, &info);
-  SCS(free_data)(d, k, stgs);
+
+  SCS(free_data)(d);
+  SCS(free_cone)(k);
   SCS(free_sol)(sol);
+  scs_free(stgs);
+
   return 0;
 }