scs 0.2.2

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;
+}