scs 0.3.0 → 0.4.0

data/vendor/scs/src/scs_version.c

@@ -1,11 +1,13 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #include "glbopts.h"
 
-const char *SCS(version)(void) {
+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);
+
+#ifdef __cplusplus
 }
+#endif

data/vendor/scs/src/util.c

@@ -71,7 +71,32 @@ 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));
+  if (src->write_data_filename) {
+    dest->write_data_filename = strdup(src->write_data_filename);
+  } else {
+    dest->write_data_filename = SCS_NULL;
+  }
+  if (src->log_csv_filename) {
+    dest->log_csv_filename = strdup(src->log_csv_filename);
+  } 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 +108,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) {
@@ -106,7 +120,7 @@ void SCS(free_sol)(ScsSolution *sol) {
 }
 
 /* assumes stgs already allocated memory */
-void SCS(set_default_settings)(ScsSettings *stgs) {
+void scs_set_default_settings(ScsSettings *stgs) {
   /* These constants are defined in include/glbopts.h */
   stgs->max_iters = MAX_ITERS;
   stgs->eps_abs = EPS_ABS;

data/vendor/scs/test/minunit.h

@@ -13,10 +13,15 @@
     if (!(test))                                                               \
       return message;                                                          \
   } while (0)
-#define mu_run_test(test)                                                      \
+#define mu_run_test(test) _mu_run_test(#test, test)
+
+#define _mu_run_test(name, test)                                               \
   do {                                                                         \
+    scs_printf("*********************************************************\n"); \
+    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

@@ -10,21 +10,11 @@
 #include "scs_matrix.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
+#define _MAX_RAND_VAL (1073741823) /* 2^30 - 1 */
 
 /* uniform random number in [-1,1] */
 static scs_float rand_scs_float(void) {
-  return 2 * (((scs_float)ran_arr_next()) / RAND_MAX) - 1;
+  return 2 * (((scs_float)ran_arr_next()) / _MAX_RAND_VAL) - 1; /* in [-1, 1] */
 }
 
 void gen_random_prob_data(scs_int nnz, scs_int col_nnz, ScsData *d, ScsCone *k,
@@ -51,8 +41,8 @@ void gen_random_prob_data(scs_int nnz, scs_int col_nnz, ScsData *d, ScsCone *k,
   for (i = 0; i < m; i++) {
     y[i] = z[i] = rand_scs_float();
   }
-  tmp_cone_work = SCS(init_cone)(k, SCS_NULL, m);
-  SCS(proj_dual_cone)(y, k, tmp_cone_work, 0);
+  tmp_cone_work = SCS(init_cone)(k, m);
+  SCS(proj_dual_cone)(y, tmp_cone_work, SCS_NULL, SCS_NULL);
   SCS(finish_cone(tmp_cone_work));
 
   for (i = 0; i < m; i++) {
@@ -88,25 +78,25 @@ void gen_random_prob_data(scs_int nnz, scs_int col_nnz, ScsData *d, ScsCone *k,
   scs_free(z);
 }
 
-static scs_float get_dual_cone_dist(const scs_float *y, const ScsCone *k,
-                                    ScsConeWork *c, scs_int m) {
+static scs_float get_dual_cone_dist(const scs_float *y, ScsConeWork *c,
+                                    scs_int m) {
   scs_float dist;
   scs_float *t = (scs_float *)scs_calloc(m, sizeof(scs_float));
   memcpy(t, y, m * sizeof(scs_float));
-  SCS(proj_dual_cone)(t, k, c, 0);
+  SCS(proj_dual_cone)(t, c, SCS_NULL, SCS_NULL);
   dist = SCS(norm_inf_diff)(t, y, m);
   scs_free(t);
   return dist;
 }
 
 /* via moreau */
-static scs_float get_pri_cone_dist(const scs_float *s, const ScsCone *k,
-                                   ScsConeWork *c, scs_int m) {
+static scs_float get_pri_cone_dist(const scs_float *s, ScsConeWork *c,
+                                   scs_int m) {
   scs_float dist;
   scs_float *t = (scs_float *)scs_calloc(m, sizeof(scs_float));
   memcpy(t, s, m * sizeof(scs_float));
   SCS(scale_array)(t, -1.0, m);
-  SCS(proj_dual_cone)(t, k, c, 0);
+  SCS(proj_dual_cone)(t, c, SCS_NULL, SCS_NULL);
   dist = SCS(norm_inf)(t, m); /* ||s - Pi_c(s)|| = ||Pi_c*(-s)|| */
   scs_free(t);
   return dist;
@@ -123,11 +113,11 @@ const char *verify_solution_correct(ScsData *d, ScsCone *k, ScsSettings *stgs,
   scs_float *c = d->c;
   scs_float *b = d->b;
 
-  scs_float *primal = scs_calloc(m, sizeof(scs_float));
-  scs_float *ax = scs_calloc(m, sizeof(scs_float));
-  scs_float *dual = scs_calloc(n, sizeof(scs_float));
-  scs_float *px = scs_calloc(n, sizeof(scs_float));
-  scs_float *aty = scs_calloc(n, sizeof(scs_float));
+  scs_float *primal = (scs_float *)scs_calloc(m, sizeof(scs_float));
+  scs_float *ax = (scs_float *)scs_calloc(m, sizeof(scs_float));
+  scs_float *dual = (scs_float *)scs_calloc(n, sizeof(scs_float));
+  scs_float *px = (scs_float *)scs_calloc(n, sizeof(scs_float));
+  scs_float *aty = (scs_float *)scs_calloc(n, sizeof(scs_float));
 
   scs_float res_pri, res_dual, res_infeas, res_unbdd_a, res_unbdd_p;
   scs_float ctx, bty, xt_p_x, gap, pobj, dobj, sty;
@@ -135,7 +125,7 @@ const char *verify_solution_correct(ScsData *d, ScsCone *k, ScsSettings *stgs,
 
   scs_float sdist = NAN, ydist = NAN;
 
-  ScsConeWork *cone_work = SCS(init_cone)(k, SCS_NULL, m);
+  ScsConeWork *cone_work = SCS(init_cone)(k, m);
 
   /**************** PRIMAL *********************/
   memset(ax, 0, m * sizeof(scs_float));
@@ -182,10 +172,10 @@ const char *verify_solution_correct(ScsData *d, ScsCone *k, ScsSettings *stgs,
   /**************** CONES *****************/
 
   if (status == SCS_SOLVED || status == SCS_UNBOUNDED) {
-    sdist = get_pri_cone_dist(sol->s, k, cone_work, m);
+    sdist = get_pri_cone_dist(sol->s, cone_work, m);
   }
   if (status == SCS_SOLVED || status == SCS_INFEASIBLE) {
-    ydist = get_dual_cone_dist(sol->y, k, cone_work, m);
+    ydist = get_dual_cone_dist(sol->y, cone_work, m);
   }
 
   /**************** OTHERS *****************/
@@ -215,14 +205,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-12);
+                   1e-10);
     mu_assert_less("Dual residual ERROR", ABS(res_dual - info->res_dual),
-                   1e-12);
-    mu_assert_less("Gap ERROR", ABS(gap - info->gap), 1e-12);
-    mu_assert_less("Primal obj ERROR", ABS(pobj - info->pobj), 1e-12);
-    mu_assert_less("Dual obj ERROR", ABS(dobj - info->dobj), 1e-12);
+                   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-6);
+    mu_assert_less("Complementary slackness ERROR", ABS(sty),
+                   1e-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);
 
@@ -230,7 +223,7 @@ const char *verify_solution_correct(ScsData *d, ScsCone *k, ScsSettings *stgs,
                    stgs->eps_abs + stgs->eps_rel * prl);
     mu_assert_less("Dual feas ERROR", res_dual,
                    stgs->eps_abs + stgs->eps_rel * drl);
-    mu_assert_less("Gap ERROR", gap, stgs->eps_abs + stgs->eps_rel * grl);
+    mu_assert_less("Gap feas ERROR", gap, stgs->eps_abs + stgs->eps_rel * grl);
 
   } else if (status == SCS_INFEASIBLE) {
     mu_assert_less("Infeas ERROR", ABS(res_infeas - info->res_infeas), 1e-8);

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"
@@ -58,7 +59,7 @@ static const char *degenerate(void) {
   d->P->i = Pi;
   d->P->p = Pp;
 
-  SCS(set_default_settings)(stgs);
+  scs_set_default_settings(stgs);
   stgs->eps_abs = 1e-6;
   stgs->eps_rel = 1e-6;
   stgs->eps_infeas = 1e-9;

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"
@@ -64,7 +65,7 @@ static const char *hs21_tiny_qp(void) {
   k->bl = bl;
   k->bu = bu;
 
-  SCS(set_default_settings)(stgs);
+  scs_set_default_settings(stgs);
   stgs->eps_abs = 1e-6;
   stgs->eps_rel = 1e-6;
   stgs->eps_infeas = 1e-9;

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"
@@ -66,7 +67,7 @@ static const char *hs21_tiny_qp_rw(void) {
   k->bl = bl;
   k->bu = bu;
 
-  SCS(set_default_settings)(stgs);
+  scs_set_default_settings(stgs);
   stgs->eps_abs = 1e-6;
   stgs->eps_rel = 1e-6;
   stgs->eps_infeas = 1e-9;
@@ -110,7 +111,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"
@@ -78,7 +79,7 @@ static const char *infeasible_tiny_qp(void) {
 
   k->l = l;
 
-  SCS(set_default_settings)(stgs);
+  scs_set_default_settings(stgs);
   stgs->eps_abs = 1e-6;
   stgs->eps_rel = 1e-6;
   stgs->eps_infeas = 1e-9;

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"
@@ -118,9 +119,9 @@ static const char *qafiro_tiny_qp(void) {
   k->bu = bu;
   k->z = z;
 
-  SCS(set_default_settings)(stgs);
-  stgs->eps_abs = 1e-6;
-  stgs->eps_rel = 1e-6;
+  scs_set_default_settings(stgs);
+  stgs->eps_abs = 1e-7;
+  stgs->eps_rel = 1e-7;
   stgs->eps_infeas = 1e-9;
 
   exitflag = scs(d, k, stgs, sol, &info);
@@ -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,6 +1,7 @@
 #include "glbopts.h"
 #include "minunit.h"
 #include "problem_utils.h"
+#include "rw.h"
 #include "scs.h"
 #include "util.h"
 
@@ -27,7 +28,7 @@ static const char *random_prob(void) {
   stgs->eps_abs = 1e-6;
   stgs->eps_rel = 1e-6;
 
-  sol = scs_calloc(1, sizeof(ScsSolution));
+  sol = (ScsSolution *)scs_calloc(1, sizeof(ScsSolution));
   exitflag = scs(d, k, stgs, sol, &info);
 
   perr = SCS(dot)(d->c, sol->x, d->n) - OPT;
@@ -39,7 +40,10 @@ static const char *random_prob(void) {
 
   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_data)(d);
+  SCS(free_cone)(k);
   SCS(free_sol)(sol);
+  scs_free(stgs);
+
   return fail;
 }

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"
@@ -155,7 +157,7 @@ static const char *rob_gauss_cov_est(void) {
   k->p = p;
   k->psize = psize;
 
-  SCS(set_default_settings)(stgs);
+  scs_set_default_settings(stgs);
   stgs->eps_abs = 1e-6;
   stgs->eps_rel = 1e-6;
   stgs->eps_infeas = 1e-9;
@@ -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;
@@ -236,7 +240,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

@@ -28,13 +28,15 @@ static const char *small_lp(void) {
   d->m = m;
   d->n = n;
   gen_random_prob_data(nnz, col_nnz, d, k, opt_sol, seed);
-  SCS(set_default_settings)(stgs);
+  scs_set_default_settings(stgs);
   stgs->eps_abs = 1e-5;
   stgs->eps_rel = 1e-5;
 
   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("true obj %4e\n", SCS(dot)(d->c, opt_sol->x, d->n));
   scs_printf("primal obj error %4e\n", perr);
   scs_printf("dual obj error %4e\n", derr);
 
@@ -42,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;
 }