scs 0.2.0

data/vendor/scs/src/ctrlc.c

@@ -0,0 +1,77 @@
+/*
+ * Implements signal handling (ctrl-c) for SCS.
+ *
+ * Under Windows, we use SetConsoleCtrlHandler.
+ * Under Unix systems, we use sigaction.
+ * For Mex files, we use utSetInterruptEnabled/utIsInterruptPending.
+ *
+ */
+
+#include "ctrlc.h"
+
+#if CTRLC > 0
+
+#ifdef MATLAB_MEX_FILE
+#include <stdbool.h>
+
+extern bool utIsInterruptPending(void);
+extern bool utSetInterruptEnabled(bool);
+
+static int istate;
+void scs_start_interrupt_listener(void) {
+  istate = (int)utSetInterruptEnabled(true);
+}
+
+void scs_end_interrupt_listener(void) { utSetInterruptEnabled((bool)istate); }
+
+int scs_is_interrupted(void) { return (int)utIsInterruptPending(); }
+
+#elif (defined _WIN32 || _WIN64 || defined _WINDLL)
+#include <windows.h>
+
+static int int_detected;
+static BOOL WINAPI scs_handle_ctrlc(DWORD dwCtrlType) {
+  if (dwCtrlType != CTRL_C_EVENT) {
+    return FALSE;
+  }
+  int_detected = 1;
+  return TRUE;
+}
+
+void scs_start_interrupt_listener(void) {
+  int_detected = 0;
+  SetConsoleCtrlHandler(scs_handle_ctrlc, TRUE);
+}
+
+void scs_end_interrupt_listener(void) {
+  SetConsoleCtrlHandler(scs_handle_ctrlc, FALSE);
+}
+
+int scs_is_interrupted(void) { return int_detected; }
+
+#else /* Unix */
+
+#include <signal.h>
+static int int_detected;
+struct sigaction oact;
+static void scs_handle_ctrlc(int dummy) { int_detected = dummy ? dummy : -1; }
+
+void scs_start_interrupt_listener(void) {
+  struct sigaction act;
+  int_detected = 0;
+  act.sa_flags = 0;
+  sigemptyset(&act.sa_mask);
+  act.sa_handler = scs_handle_ctrlc;
+  sigaction(SIGINT, &act, &oact);
+}
+
+void scs_end_interrupt_listener(void) {
+  struct sigaction act;
+  sigaction(SIGINT, &oact, &act);
+}
+
+int scs_is_interrupted(void) { return int_detected; }
+
+#endif /* END IF MATLAB_MEX_FILE / WIN32 */
+
+#endif /* END IF CTRLC > 0 */

data/vendor/scs/src/linalg.c

@@ -0,0 +1,84 @@
+#include "linalg.h"
+#include <math.h>
+
+/* x = b*a */
+void SCS(set_as_scaled_array)(scs_float *x, const scs_float *a,
+                              const scs_float b, scs_int len) {
+  scs_int i;
+  for (i = 0; i < len; ++i) x[i] = b * a[i];
+}
+
+/* a *= b */
+void SCS(scale_array)(scs_float *a, const scs_float b, scs_int len) {
+  scs_int i;
+  for (i = 0; i < len; ++i) a[i] *= b;
+}
+
+/* x'*y */
+scs_float SCS(dot)(const scs_float *x, const scs_float *y, scs_int len) {
+  scs_int i;
+  scs_float ip = 0.0;
+  for (i = 0; i < len; ++i) {
+    ip += x[i] * y[i];
+  }
+  return ip;
+}
+
+/* ||v||_2^2 */
+scs_float SCS(norm_sq)(const scs_float *v, scs_int len) {
+  scs_int i;
+  scs_float nmsq = 0.0;
+  for (i = 0; i < len; ++i) {
+    nmsq += v[i] * v[i];
+  }
+  return nmsq;
+}
+
+/* ||v||_2 */
+scs_float SCS(norm)(const scs_float *v, scs_int len) {
+  return SQRTF(SCS(norm_sq)(v, len));
+}
+
+scs_float SCS(norm_inf)(const scs_float *a, scs_int l) {
+  scs_float tmp, max = 0.0;
+  scs_int i;
+  for (i = 0; i < l; ++i) {
+    tmp = ABS(a[i]);
+    if (tmp > max) {
+      max = tmp;
+    }
+  }
+  return max;
+}
+
+/* saxpy a += sc*b */
+void SCS(add_scaled_array)(scs_float *a, const scs_float *b, scs_int n,
+                           const scs_float sc) {
+  scs_int i;
+  for (i = 0; i < n; ++i) {
+    a[i] += sc * b[i];
+  }
+}
+
+scs_float SCS(norm_diff)(const scs_float *a, const scs_float *b, scs_int l) {
+  scs_float nm_diff = 0.0, tmp;
+  scs_int i;
+  for (i = 0; i < l; ++i) {
+    tmp = (a[i] - b[i]);
+    nm_diff += tmp * tmp;
+  }
+  return SQRTF(nm_diff);
+}
+
+scs_float SCS(norm_inf_diff)(const scs_float *a, const scs_float *b,
+                             scs_int l) {
+  scs_float tmp, max = 0.0;
+  scs_int i;
+  for (i = 0; i < l; ++i) {
+    tmp = ABS(a[i] - b[i]);
+    if (tmp > max) {
+      max = tmp;
+    }
+  }
+  return max;
+}

data/vendor/scs/src/normalize.c

@@ -0,0 +1,93 @@
+#include "normalize.h"
+#include "linalg.h"
+#include "scs.h"
+
+#define MIN_SCALE (1e-6)
+
+void SCS(normalize_b_c)(ScsWork *w) {
+  scs_int i;
+  scs_float nm, *D = w->scal->D, *E = w->scal->E, *b = w->b, *c = w->c;
+  /* scale b */
+  for (i = 0; i < w->m; ++i) {
+    b[i] /= D[i];
+  }
+  nm = SCS(norm)(b, w->m);
+  w->sc_b = w->scal->mean_norm_col_a / MAX(nm, MIN_SCALE);
+  /* scale c */
+  for (i = 0; i < w->n; ++i) {
+    c[i] /= E[i];
+  }
+  nm = SCS(norm)(c, w->n);
+  w->sc_c = w->scal->mean_norm_row_a / MAX(nm, MIN_SCALE);
+  SCS(scale_array)(b, w->sc_b * w->stgs->scale, w->m);
+  SCS(scale_array)(c, w->sc_c * w->stgs->scale, w->n);
+}
+
+void SCS(calc_scaled_resids)(ScsWork *w, ScsResiduals *r) {
+  scs_float *D = w->scal->D;
+  scs_float *E = w->scal->E;
+  scs_float *u = w->u;
+  scs_float *u_t = w->u_t;
+  scs_float *u_prev = w->u_prev;
+  scs_float tmp;
+  scs_int i, n = w->n, m = w->m;
+
+  r->res_pri = 0;
+  for (i = 0; i < n; ++i) {
+    tmp = (u[i] - u_t[i]) / (E[i] * w->sc_b);
+    r->res_pri += tmp * tmp;
+  }
+  for (i = 0; i < m; ++i) {
+    tmp = (u[i + n] - u_t[i + n]) / (D[i] * w->sc_c);
+    r->res_pri += tmp * tmp;
+  }
+  tmp = u[n + m] - u_t[n + m];
+  r->res_pri += tmp * tmp;
+  r->res_pri = sqrt(r->res_pri);
+
+  r->res_dual = 0;
+  for (i = 0; i < n; ++i) {
+    tmp = (u[i] - u_prev[i]) * E[i] / w->sc_b;
+    r->res_dual += tmp * tmp;
+  }
+  for (i = 0; i < m; ++i) {
+    tmp = (u[i + n] - u_prev[i + n]) * D[i] / w->sc_c;
+    r->res_dual += tmp * tmp;
+  }
+  tmp = u[n + m] - u_t[n + m];
+  r->res_dual += tmp * tmp;
+  r->res_dual = sqrt(r->res_dual);
+}
+
+void SCS(normalize_warm_start)(ScsWork *w) {
+  scs_int i;
+  scs_float *D = w->scal->D;
+  scs_float *E = w->scal->E;
+  scs_float *x = w->u;
+  scs_float *y = &(w->u[w->n]);
+  scs_float *s = &(w->v[w->n]);
+  for (i = 0; i < w->n; ++i) {
+    x[i] *= (E[i] * w->sc_b);
+  }
+  for (i = 0; i < w->m; ++i) {
+    y[i] *= (D[i] * w->sc_c);
+  }
+  for (i = 0; i < w->m; ++i) {
+    s[i] /= (D[i] / (w->sc_b * w->stgs->scale));
+  }
+}
+
+void SCS(un_normalize_sol)(ScsWork *w, ScsSolution *sol) {
+  scs_int i;
+  scs_float *D = w->scal->D;
+  scs_float *E = w->scal->E;
+  for (i = 0; i < w->n; ++i) {
+    sol->x[i] /= (E[i] * w->sc_b);
+  }
+  for (i = 0; i < w->m; ++i) {
+    sol->y[i] /= (D[i] * w->sc_c);
+  }
+  for (i = 0; i < w->m; ++i) {
+    sol->s[i] *= D[i] / (w->sc_b * w->stgs->scale);
+  }
+}

data/vendor/scs/src/rw.c

@@ -0,0 +1,167 @@
+#include "rw.h"
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "amatrix.h"
+#include "scs.h"
+#include "util.h"
+
+/* writes/reads problem data to/from filename */
+/* This is a VERY naive implementation, doesn't care about portability etc */
+
+static void write_scs_cone(const ScsCone *k, FILE *fout) {
+  fwrite(&(k->f), sizeof(scs_int), 1, fout);
+  fwrite(&(k->l), sizeof(scs_int), 1, fout);
+  fwrite(&(k->qsize), sizeof(scs_int), 1, fout);
+  fwrite(k->q, sizeof(scs_int), k->qsize, fout);
+  fwrite(&(k->ssize), sizeof(scs_int), 1, fout);
+  fwrite(k->s, sizeof(scs_int), k->ssize, fout);
+  fwrite(&(k->ep), sizeof(scs_int), 1, fout);
+  fwrite(&(k->ed), sizeof(scs_int), 1, fout);
+  fwrite(&(k->psize), sizeof(scs_int), 1, fout);
+  fwrite(k->p, sizeof(scs_float), k->psize, fout);
+}
+
+static ScsCone *read_scs_cone(FILE *fin) {
+  ScsCone *k = (ScsCone *)scs_calloc(1, sizeof(ScsCone));
+  fread(&(k->f), sizeof(scs_int), 1, fin);
+  fread(&(k->l), sizeof(scs_int), 1, fin);
+  fread(&(k->qsize), sizeof(scs_int), 1, fin);
+  k->q = scs_calloc(k->qsize, sizeof(scs_int));
+  fread(k->q, sizeof(scs_int), k->qsize, fin);
+  fread(&(k->ssize), sizeof(scs_int), 1, fin);
+  k->s = scs_calloc(k->ssize, sizeof(scs_int));
+  fread(k->s, sizeof(scs_int), k->ssize, fin);
+  fread(&(k->ep), sizeof(scs_int), 1, fin);
+  fread(&(k->ed), sizeof(scs_int), 1, fin);
+  fread(&(k->psize), sizeof(scs_int), 1, fin);
+  k->p = scs_calloc(k->psize, sizeof(scs_int));
+  fread(k->p, sizeof(scs_float), k->psize, fin);
+  return k;
+}
+
+static void write_scs_stgs(const ScsSettings *s, FILE *fout) {
+  /* Warm start to false for now */
+  scs_int warm_start = 0;
+  fwrite(&(s->normalize), sizeof(scs_int), 1, fout);
+  fwrite(&(s->scale), sizeof(scs_float), 1, fout);
+  fwrite(&(s->rho_x), sizeof(scs_float), 1, fout);
+  fwrite(&(s->max_iters), sizeof(scs_int), 1, fout);
+  fwrite(&(s->eps), sizeof(scs_float), 1, fout);
+  fwrite(&(s->alpha), sizeof(scs_float), 1, fout);
+  fwrite(&(s->cg_rate), sizeof(scs_float), 1, fout);
+  fwrite(&(s->verbose), sizeof(scs_int), 1, fout);
+  fwrite(&warm_start, sizeof(scs_int), 1, fout);
+  fwrite(&(s->acceleration_lookback), sizeof(scs_int), 1, fout);
+  /* Do not write the write_data_filename */
+}
+
+static ScsSettings *read_scs_stgs(FILE *fin) {
+  ScsSettings *s = (ScsSettings *)scs_calloc(1, sizeof(ScsSettings));
+  fread(&(s->normalize), sizeof(scs_int), 1, fin);
+  fread(&(s->scale), sizeof(scs_float), 1, fin);
+  fread(&(s->rho_x), sizeof(scs_float), 1, fin);
+  fread(&(s->max_iters), sizeof(scs_int), 1, fin);
+  fread(&(s->eps), sizeof(scs_float), 1, fin);
+  fread(&(s->alpha), sizeof(scs_float), 1, fin);
+  fread(&(s->cg_rate), sizeof(scs_float), 1, fin);
+  fread(&(s->verbose), sizeof(scs_int), 1, fin);
+  fread(&(s->warm_start), sizeof(scs_int), 1, fin);
+  fread(&(s->acceleration_lookback), sizeof(scs_int), 1, fin);
+  return s;
+}
+
+static void write_amatrix(const ScsMatrix *A, FILE *fout) {
+  scs_int Anz = A->p[A->n];
+  fwrite(&(A->m), sizeof(scs_int), 1, fout);
+  fwrite(&(A->n), sizeof(scs_int), 1, fout);
+  fwrite(A->p, sizeof(scs_int), A->n + 1, fout);
+  fwrite(A->x, sizeof(scs_float), Anz, fout);
+  fwrite(A->i, sizeof(scs_int), Anz, fout);
+}
+
+static ScsMatrix *read_amatrix(FILE *fin) {
+  scs_int Anz;
+  ScsMatrix *A = (ScsMatrix *)scs_calloc(1, sizeof(ScsMatrix));
+  fread(&(A->m), sizeof(scs_int), 1, fin);
+  fread(&(A->n), sizeof(scs_int), 1, fin);
+  A->p = scs_calloc(A->n + 1, sizeof(scs_int));
+  fread(A->p, sizeof(scs_int), A->n + 1, fin);
+  Anz = A->p[A->n];
+  A->x = scs_calloc(Anz, sizeof(scs_float));
+  A->i = scs_calloc(Anz, sizeof(scs_int));
+  fread(A->x, sizeof(scs_float), Anz, fin);
+  fread(A->i, sizeof(scs_int), Anz, fin);
+  return A;
+}
+
+static void write_scs_data(const ScsData *d, FILE *fout) {
+  fwrite(&(d->m), sizeof(scs_int), 1, fout);
+  fwrite(&(d->n), sizeof(scs_int), 1, fout);
+  fwrite(d->b, sizeof(scs_float), d->m, fout);
+  fwrite(d->c, sizeof(scs_float), d->n, fout);
+  write_scs_stgs(d->stgs, fout);
+  write_amatrix(d->A, fout);
+}
+
+static ScsData *read_scs_data(FILE *fin) {
+  ScsData *d = (ScsData *)scs_calloc(1, sizeof(ScsData));
+  fread(&(d->m), sizeof(scs_int), 1, fin);
+  fread(&(d->n), sizeof(scs_int), 1, fin);
+  d->b = scs_calloc(d->m, sizeof(scs_float));
+  d->c = scs_calloc(d->n, sizeof(scs_float));
+  fread(d->b, sizeof(scs_float), d->m, fin);
+  fread(d->c, sizeof(scs_float), d->n, fin);
+  d->stgs = read_scs_stgs(fin);
+  d->A = read_amatrix(fin);
+  return d;
+}
+
+void SCS(write_data)(const ScsData *d, const ScsCone *k) {
+  FILE *fout = fopen(d->stgs->write_data_filename, "wb");
+  uint32_t scs_int_sz = (uint32_t)sizeof(scs_int);
+  uint32_t scs_float_sz = (uint32_t)sizeof(scs_float);
+  scs_printf("writing data to %s\n", d->stgs->write_data_filename);
+  fwrite(&(scs_int_sz), sizeof(uint32_t), 1, fout);
+  fwrite(&(scs_float_sz), sizeof(uint32_t), 1, fout);
+  write_scs_cone(k, fout);
+  write_scs_data(d, fout);
+  fclose(fout);
+}
+
+scs_int SCS(read_data)(const char *filename, ScsData **d, ScsCone **k) {
+  uint32_t file_int_sz;
+  uint32_t file_float_sz;
+  FILE *fin = fopen(filename, "rb");
+  if (!fin) {
+    scs_printf("Error reading file %s\n", filename);
+    return -1;
+  }
+  scs_printf("Reading data from %s\n", filename);
+  fread(&(file_int_sz), sizeof(uint32_t), 1, fin);
+  fread(&(file_float_sz), sizeof(uint32_t), 1, fin);
+
+  if (file_int_sz != (uint32_t)sizeof(scs_int)) {
+    scs_printf(
+        "Error, sizeof(file int) is %lu, but scs expects sizeof(int) "
+        "%lu, scs should be recompiled with correct flags.\n",
+        (unsigned long)file_int_sz, (unsigned long)sizeof(scs_int));
+    fclose(fin);
+    return -1;
+  }
+  if (file_float_sz != (uint32_t)sizeof(scs_float)) {
+    scs_printf(
+        "Error, sizeof(file float) is %lu, but scs expects "
+        "sizeof(float) %lu, scs should be recompiled with the correct flags.\n",
+        (unsigned long)file_float_sz, (unsigned long)sizeof(scs_float));
+    fclose(fin);
+    return -1;
+  }
+
+  *k = read_scs_cone(fin);
+  *d = read_scs_data(fin);
+  fclose(fin);
+  return 0;
+}