scs 0.2.0

data/vendor/scs/include/scs.h

@@ -0,0 +1,161 @@
+#ifndef SCS_H_GUARD
+#define SCS_H_GUARD
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <string.h>
+#include "glbopts.h"
+#include "aa.h"
+
+/* private data structs (that you define) containing any necessary data to solve
+ * linear system, etc. this defines the matrix A, only the linear system solver
+ * interacts with this struct */
+typedef struct SCS_A_DATA_MATRIX ScsMatrix;
+/* stores the necessary private workspace, only the linear system solver
+ * interacts with this struct */
+typedef struct SCS_LIN_SYS_WORK ScsLinSysWork;
+
+typedef struct SCS_PROBLEM_DATA ScsData;
+typedef struct SCS_SETTINGS ScsSettings;
+typedef struct SCS_SOL_VARS ScsSolution;
+typedef struct SCS_INFO ScsInfo;
+typedef struct SCS_SCALING ScsScaling;
+typedef struct SCS_WORK ScsWork;
+typedef struct SCS_RESIDUALS ScsResiduals;
+typedef struct SCS_CONE ScsCone;
+typedef struct SCS_ACCEL_WORK ScsAccelWork;
+typedef struct SCS_CONE_WORK ScsConeWork;
+
+/* struct containing problem data */
+struct SCS_PROBLEM_DATA {
+  /* these cannot change for multiple runs for the same call to SCS(init) */
+  scs_int m, n; /* A has m rows, n cols */
+  ScsMatrix *A; /* A is supplied in data format specified by linsys solver */
+
+  /* these can change for multiple runs for the same call to SCS(init) */
+  scs_float *b, *c; /* dense arrays for b (size m), c (size n) */
+
+  ScsSettings *stgs; /* contains solver settings specified by user */
+};
+
+/* ScsSettings struct */
+struct SCS_SETTINGS {
+  /* settings parameters: default suggested input */
+
+  /* these *cannot* change for multiple runs with the same call to SCS(init) */
+  scs_int normalize; /* boolean, heuristic data rescaling: 1 */
+  scs_float scale;   /* if normalized, rescales by this factor: 5 */
+  scs_float rho_x;   /* x equality constraint scaling: 1e-3 */
+
+  /* these can change for multiple runs with the same call to SCS(init) */
+  scs_int max_iters;  /* maximum iterations to take: 2500 */
+  scs_float eps;      /* convergence tolerance: 1e-3 */
+  scs_float alpha;    /* relaxation parameter: 1.8 */
+  scs_float cg_rate;  /* for indirect, tolerance goes down like
+                         (1/iter)^cg_rate: 2 */
+  scs_int verbose;    /* boolean, write out progress: 1 */
+  scs_int warm_start; /* boolean, warm start (put initial guess in ScsSolution
+                         struct): 0 */
+  scs_int acceleration_lookback; /* memory for acceleration */
+  const char* write_data_filename; /* string, if set will dump data */
+};
+
+/* NB: rows of data matrix A must be specified in this exact order */
+struct SCS_CONE {
+  scs_int f;     /* number of linear equality constraints */
+  scs_int l;     /* length of LP cone */
+  scs_int *q;    /* array of second-order cone constraints */
+  scs_int qsize; /* length of SOC array */
+  scs_int *s;    /* array of SD constraints */
+  scs_int ssize; /* length of SD array */
+  scs_int ep;    /* number of primal exponential cone triples */
+  scs_int ed;    /* number of dual exponential cone triples */
+  scs_float *p;  /* array of power cone params, must be \in [-1, 1],
+                    negative values are interpreted as specifying the
+                    dual cone */
+  scs_int psize; /* number of (primal and dual) power cone triples */
+};
+
+/* contains primal-dual solution arrays */
+struct SCS_SOL_VARS {
+  scs_float *x, *y, *s;
+};
+
+/* contains terminating information */
+struct SCS_INFO {
+  scs_int iter;         /* number of iterations taken */
+  char status[32];      /* status string, e.g. 'Solved' */
+  scs_int status_val;   /* status as scs_int, defined in glbopts.h */
+  scs_float pobj;       /* primal objective */
+  scs_float dobj;       /* dual objective */
+  scs_float res_pri;    /* primal equality residual */
+  scs_float res_dual;   /* dual equality residual */
+  scs_float res_infeas; /* infeasibility cert residual */
+  scs_float res_unbdd;  /* unbounded cert residual */
+  scs_float rel_gap;    /* relative duality gap */
+  scs_float setup_time; /* time taken for setup phase (milliseconds) */
+  scs_float solve_time; /* time taken for solve phase (milliseconds) */
+};
+
+/* contains normalization variables */
+struct SCS_SCALING {
+  scs_float *D, *E; /* for normalization */
+  scs_float mean_norm_row_a, mean_norm_col_a;
+};
+
+/*
+ * main library api's:
+ * SCS(init): allocates memory etc (e.g., factorize matrix [I A; A^T -I])
+ * SCS(solve): can be called many times with different b,c data per init call
+ * SCS(finish): cleans up the memory (one per init call)
+ */
+ScsWork *SCS(init)(const ScsData *d, const ScsCone *k, ScsInfo *info);
+scs_int SCS(solve)(ScsWork *w, const ScsData *d, const ScsCone *k,
+                   ScsSolution *sol, ScsInfo *info);
+void SCS(finish)(ScsWork *w);
+/* scs calls SCS(init), SCS(solve), and SCS(finish) */
+scs_int scs(const ScsData *d, const ScsCone *k, ScsSolution *sol,
+            ScsInfo *info);
+
+const char *SCS(version)(void);
+size_t SCS(sizeof_int)(void);
+size_t SCS(sizeof_float)(void);
+
+/* the following structs are not exposed to user */
+
+/* workspace for SCS */
+struct SCS_WORK {
+  /* x_prev = x from previous iteration */
+  scs_float *u, *u_best, *v, *v_best, *u_t, *u_prev, *v_prev;
+  scs_float *h, *g, *pr, *dr;
+  scs_float g_th, sc_b, sc_c, nm_b, nm_c, best_max_residual;
+  scs_float *b, *c;       /* (possibly normalized) b and c vectors */
+  scs_int m, n;           /* A has m rows, n cols */
+  ScsMatrix *A;           /* (possibly normalized) A matrix */
+  ScsLinSysWork *p;       /* struct populated by linear system solver */
+  ScsSettings *stgs;      /* contains solver settings specified by user */
+  ScsScaling *scal;       /* contains the re-scaling data */
+  ScsConeWork *cone_work; /* workspace for the cone projection step */
+  AaWork *accel;          /* Struct for acceleration workspace */
+};
+
+/* to hold residual information (unnormalized) */
+struct SCS_RESIDUALS {
+  scs_int last_iter;
+  scs_float res_dual;
+  scs_float res_pri;
+  scs_float res_infeas;
+  scs_float res_unbdd;
+  scs_float rel_gap;
+  scs_float ct_x_by_tau; /* not divided by tau */
+  scs_float bt_y_by_tau; /* not divided by tau */
+  scs_float tau;
+  scs_float kap;
+};
+
+#ifdef __cplusplus
+}
+#endif
+#endif

data/vendor/scs/include/scs_blas.h

@@ -0,0 +1,51 @@
+#ifndef SCS_BLAS_H_GUARD
+#define SCS_BLAS_H_GUARD
+
+#ifdef USE_LAPACK
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Default to underscore for blas / lapack */
+#ifndef BLASSUFFIX
+#define BLASSUFFIX _
+#endif
+
+/* annoying hack because some preprocessors can't handle empty macros */
+#if defined(NOBLASSUFFIX) && NOBLASSUFFIX > 0
+/* single or double precision */
+#ifndef SFLOAT
+#define BLAS(x) d##x
+#else
+#define BLAS(x) s##x
+#endif
+#else
+/* this extra indirection is needed for BLASSUFFIX to work correctly as a
+ * variable */
+#define stitch_(pre, x, post) pre##x##post
+#define stitch__(pre, x, post) stitch_(pre, x, post)
+/* single or double precision */
+#ifndef SFLOAT
+#define BLAS(x) stitch__(d, x, BLASSUFFIX)
+#else
+#define BLAS(x) stitch__(s, x, BLASSUFFIX)
+#endif
+#endif
+
+#ifdef MATLAB_MEX_FILE
+typedef ptrdiff_t blas_int;
+#elif defined BLAS64
+#include <stdint.h>
+typedef int64_t blas_int;
+#else
+typedef int blas_int;
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* USE_LAPACK */
+
+#endif /* SCS_BLAS_H_GUARD */

data/vendor/scs/include/util.h

@@ -0,0 +1,65 @@
+#ifndef UTIL_H_GUARD
+#define UTIL_H_GUARD
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "cones.h"
+#include "scs.h"
+
+/* timing code courtesy of A. Domahidi */
+#if (defined NOTIMER)
+typedef void *SCS(timer);
+#elif (defined _WIN32 || defined _WIN64 || defined _WINDLL)
+/* Use Windows QueryPerformanceCounter for timing */
+#include <windows.h>
+typedef struct SCS(timer) {
+  LARGE_INTEGER tic;
+  LARGE_INTEGER toc;
+  LARGE_INTEGER freq;
+} SCS(timer);
+
+#elif (defined __APPLE__)
+/* Use MAC OSX mach_time for timing */
+#include <mach/mach_time.h>
+typedef struct SCS(timer) {
+  uint64_t tic;
+  uint64_t toc;
+  mach_timebase_info_data_t tinfo;
+} SCS(timer);
+
+#else
+/* Use POSIX clock_gettime() for timing on other machines */
+#include <time.h>
+typedef struct SCS(timer) {
+  struct timespec tic;
+  struct timespec toc;
+} SCS(timer);
+
+#endif
+
+#if EXTRA_VERBOSE > 1
+extern SCS(timer) global_timer;
+#endif
+
+/* these all return milli-seconds */
+void SCS(tic)(SCS(timer) * t);
+scs_float SCS(toc)(SCS(timer) * t);
+scs_float SCS(str_toc)(char *str, SCS(timer) * t);
+scs_float SCS(tocq)(SCS(timer) * t);
+
+void SCS(print_cone_data)(const ScsCone *k);
+void SCS(print_data)(const ScsData *d);
+void SCS(print_work)(const ScsWork *w);
+void SCS(print_array)(const scs_float *arr, scs_int n, const char *name);
+void SCS(set_default_settings)(ScsData *d);
+void SCS(free_sol)(ScsSolution *sol);
+void SCS(free_data)(ScsData *d, ScsCone *k);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

data/vendor/scs/linsys/amatrix.c

@@ -0,0 +1,305 @@
+/* contains routines common to direct and indirect sparse solvers */
+#include "amatrix.h"
+
+#include "linsys.h"
+
+#define MIN_SCALE (1e-4)
+#define MAX_SCALE (1e4)
+#define NUM_SCALE_PASSES 10 /* additional passes don't help much */
+
+scs_int SCS(copy_a_matrix)(ScsMatrix **dstp, const ScsMatrix *src) {
+  scs_int Anz = src->p[src->n];
+  ScsMatrix *A = (ScsMatrix *)scs_calloc(1, sizeof(ScsMatrix));
+  if (!A) {
+    return 0;
+  }
+  A->n = src->n;
+  A->m = src->m;
+  A->x = (scs_float *)scs_malloc(sizeof(scs_float) *
+                                 Anz); /* A values, size: NNZ A */
+  A->i = (scs_int *)scs_malloc(sizeof(scs_int) *
+                               Anz); /* A row index, size: NNZ A */
+  A->p = (scs_int *)scs_malloc(sizeof(scs_int) *
+                               (src->n + 1)); /* A column pointer, size: n+1 */
+  if (!A->x || !A->i || !A->p) {
+    return 0;
+  }
+  memcpy(A->x, src->x, sizeof(scs_float) * Anz);
+  memcpy(A->i, src->i, sizeof(scs_int) * Anz);
+  memcpy(A->p, src->p, sizeof(scs_int) * (src->n + 1));
+  *dstp = A;
+  return 1;
+}
+
+scs_int SCS(validate_lin_sys)(const ScsMatrix *A) {
+  scs_int i, r_max, Anz;
+  if (!A->x || !A->i || !A->p) {
+    scs_printf("data incompletely specified\n");
+    return -1;
+  }
+  /* detects some errors in A col ptrs: */
+  Anz = A->p[A->n];
+  if (Anz > 0) {
+    for (i = 0; i < A->n; ++i) {
+      if (A->p[i] == A->p[i + 1]) {
+        scs_printf(
+            "WARN: A->p (column pointers) not strictly increasing, "
+            "column %li empty\n",
+            (long)i);
+      } else if (A->p[i] > A->p[i + 1]) {
+        scs_printf("ERROR: A->p (column pointers) decreasing\n");
+        return -1;
+      }
+    }
+  }
+  if (((scs_float)Anz / A->m > A->n) || (Anz < 0)) {
+    scs_printf("Anz (nonzeros in A) = %li, outside of valid range\n",
+               (long)Anz);
+    return -1;
+  }
+  r_max = 0;
+  for (i = 0; i < Anz; ++i) {
+    if (A->i[i] > r_max) {
+      r_max = A->i[i];
+    }
+  }
+  if (r_max > A->m - 1) {
+    scs_printf("number of rows in A inconsistent with input dimension\n");
+    return -1;
+  }
+  return 0;
+}
+
+void SCS(free_a_matrix)(ScsMatrix *A) {
+  if (A) {
+    scs_free(A->x);
+    scs_free(A->i);
+    scs_free(A->p);
+    scs_free(A);
+  }
+}
+
+#if EXTRA_VERBOSE > 0
+static void print_a_matrix(const ScsMatrix *A) {
+  scs_int i, j;
+  /* TODO: this is to prevent clogging stdout */
+  if (A->p[A->n] < 2500) {
+    scs_printf("\n");
+    for (i = 0; i < A->n; ++i) {
+      scs_printf("Col %li: ", (long)i);
+      for (j = A->p[i]; j < A->p[i + 1]; j++) {
+        scs_printf("A[%li,%li] = %4f, ", (long)A->i[j], (long)i, A->x[j]);
+      }
+      scs_printf("norm col = %4f\n",
+                 SCS(norm)(&(A->x[A->p[i]]), A->p[i + 1] - A->p[i]));
+    }
+    scs_printf("norm A = %4f\n", SCS(norm)(A->x, A->p[A->n]));
+  }
+}
+#endif
+
+void SCS(_normalize_a)(ScsMatrix *A, const ScsSettings *stgs, const ScsCone *k,
+                       ScsScaling *scal) {
+  scs_float *D = (scs_float *)scs_malloc(A->m * sizeof(scs_float));
+  scs_float *E = (scs_float *)scs_malloc(A->n * sizeof(scs_float));
+  scs_float *Dt = (scs_float *)scs_malloc(A->m * sizeof(scs_float));
+  scs_float *Et = (scs_float *)scs_malloc(A->n * sizeof(scs_float));
+  scs_float *nms = (scs_float *)scs_calloc(A->m, sizeof(scs_float));
+  scs_int i, j, l, count, delta, *boundaries;
+  scs_int num_boundaries = SCS(get_cone_boundaries)(k, &boundaries);
+  scs_float wrk;
+
+#if EXTRA_VERBOSE > 0
+  SCS(timer) normalize_timer;
+  SCS(tic)(&normalize_timer);
+  scs_printf("normalizing A\n");
+  print_a_matrix(A);
+#endif
+
+  for (l = 0; l < NUM_SCALE_PASSES; ++l) {
+    memset(D, 0, A->m * sizeof(scs_float));
+    memset(E, 0, A->n * sizeof(scs_float));
+    /* calculate row norms */
+    for (i = 0; i < A->n; ++i) {
+      for (j = A->p[i]; j < A->p[i + 1]; ++j) {
+        D[A->i[j]] = MAX(D[A->i[j]], ABS(A->x[j]));
+      }
+    }
+    for (i = 0; i < A->m; ++i) {
+      D[i] = SQRTF(D[i]);
+      D[i] = D[i] < MIN_SCALE ? 1.0 : D[i];
+      D[i] = D[i] > MAX_SCALE ? MAX_SCALE : D[i];
+    }
+    /* calculate col norms, E */
+    for (i = 0; i < A->n; ++i) {
+      E[i] = SCS(norm_inf)(&(A->x[A->p[i]]), A->p[i + 1] - A->p[i]);
+      E[i] = SQRTF(E[i]);
+      E[i] = E[i] < MIN_SCALE ? 1.0 : E[i];
+      E[i] = E[i] > MAX_SCALE ? MAX_SCALE : E[i];
+    }
+
+    /* mean of D across each cone  */
+    count = boundaries[0];
+    for (i = 1; i < num_boundaries; ++i) {
+      wrk = 0;
+      delta = boundaries[i];
+      for (j = count; j < count + delta; ++j) {
+        wrk += D[j];
+      }
+      wrk /= delta;
+      for (j = count; j < count + delta; ++j) {
+        D[j] = wrk;
+      }
+      count += delta;
+    }
+
+    /* scale the rows with D */
+    for (i = 0; i < A->n; ++i) {
+      for (j = A->p[i]; j < A->p[i + 1]; ++j) {
+        A->x[j] /= D[A->i[j]];
+      }
+    }
+
+    /* scale the cols with E */
+    for (i = 0; i < A->n; ++i) {
+      SCS(scale_array)(&(A->x[A->p[i]]), 1.0 / E[i], A->p[i + 1] - A->p[i]);
+    }
+
+    /* Accumulate scaling */
+    for (i = 0; i < A->m; ++i) {
+      Dt[i] = (l == 0) ? D[i] : Dt[i] * D[i];
+    }
+    for (i = 0; i < A->n; ++i) {
+      Et[i] = (l == 0) ? E[i] : Et[i] * E[i];
+    }
+  }
+  scs_free(boundaries);
+  scs_free(D);
+  scs_free(E);
+
+  /* calculate mean of row norms of A */
+  for (i = 0; i < A->n; ++i) {
+    for (j = A->p[i]; j < A->p[i + 1]; ++j) {
+      wrk = A->x[j];
+      nms[A->i[j]] += wrk * wrk;
+    }
+  }
+  scal->mean_norm_row_a = 0.0;
+  for (i = 0; i < A->m; ++i) {
+    scal->mean_norm_row_a += SQRTF(nms[i]) / A->m;
+  }
+  scs_free(nms);
+
+  /* calculate mean of col norms of A */
+  scal->mean_norm_col_a = 0.0;
+  for (i = 0; i < A->n; ++i) {
+    scal->mean_norm_col_a +=
+        SCS(norm)(&(A->x[A->p[i]]), A->p[i + 1] - A->p[i]) / A->n;
+  }
+
+  /* scale up by d->SCALE if not equal to 1 */
+  if (stgs->scale != 1) {
+    SCS(scale_array)(A->x, stgs->scale, A->p[A->n]);
+  }
+
+  scal->D = Dt;
+  scal->E = Et;
+
+#if EXTRA_VERBOSE > 0
+  scs_printf("finished normalizing A, time: %1.2es\n",
+             SCS(tocq)(&normalize_timer) / 1e3);
+  print_a_matrix(A);
+#endif
+}
+
+void SCS(_un_normalize_a)(ScsMatrix *A, const ScsSettings *stgs,
+                          const ScsScaling *scal) {
+  scs_int i, j;
+  scs_float *D = scal->D;
+  scs_float *E = scal->E;
+  for (i = 0; i < A->n; ++i) {
+    SCS(scale_array)
+    (&(A->x[A->p[i]]), E[i] / stgs->scale, A->p[i + 1] - A->p[i]);
+  }
+  for (i = 0; i < A->n; ++i) {
+    for (j = A->p[i]; j < A->p[i + 1]; ++j) {
+      A->x[j] *= D[A->i[j]];
+    }
+  }
+}
+
+void SCS(_accum_by_atrans)(scs_int n, scs_float *Ax, scs_int *Ai, scs_int *Ap,
+                           const scs_float *x, scs_float *y) {
+  /* y += A'*x
+     A in column compressed format
+     parallelizes over columns (rows of A')
+   */
+  scs_int p, j;
+  scs_int c1, c2;
+  scs_float yj;
+#if EXTRA_VERBOSE > 0
+  SCS(timer) mult_by_atrans_timer;
+  SCS(tic)(&mult_by_atrans_timer);
+#endif
+#ifdef _OPENMP
+#pragma omp parallel for private(p, c1, c2, yj)
+#endif
+  for (j = 0; j < n; j++) {
+    yj = y[j];
+    c1 = Ap[j];
+    c2 = Ap[j + 1];
+    for (p = c1; p < c2; p++) {
+      yj += Ax[p] * x[Ai[p]];
+    }
+    y[j] = yj;
+  }
+#if EXTRA_VERBOSE > 0
+  scs_printf("mult By A trans time: %1.2es\n",
+             SCS(tocq)(&mult_by_atrans_timer) / 1e3);
+#endif
+}
+
+scs_float SCS(cumsum)(scs_int *p, scs_int *c, scs_int n) {
+  scs_int i, nz = 0;
+  scs_float nz2 = 0;
+  if (!p || !c) {
+    return (-1);
+  } /* check inputs */
+  for (i = 0; i < n; i++) {
+    p[i] = nz;
+    nz += c[i];
+    nz2 += c[i]; /* also in scs_float to avoid scs_int overflow */
+    c[i] = p[i]; /* also copy p[0..n-1] back into c[0..n-1]*/
+  }
+  p[n] = nz;
+  return nz2; /* return sum (c [0..n-1]) */
+}
+
+void SCS(_accum_by_a)(scs_int n, scs_float *Ax, scs_int *Ai, scs_int *Ap,
+                      const scs_float *x, scs_float *y) {
+  /*y += A*x
+    A in column compressed format
+    this parallelizes over columns and uses
+    pragma atomic to prevent concurrent writes to y
+   */
+  scs_int p, j;
+  scs_int c1, c2;
+  scs_float xj;
+#if EXTRA_VERBOSE > 0
+  SCS(timer) mult_by_a_timer;
+  SCS(tic)(&mult_by_a_timer);
+#endif
+  /*#pragma omp parallel for private(p,c1,c2,xj)  */
+  for (j = 0; j < n; j++) {
+    xj = x[j];
+    c1 = Ap[j];
+    c2 = Ap[j + 1];
+    for (p = c1; p < c2; p++) {
+      /*#pragma omp atomic */
+      y[Ai[p]] += Ax[p] * xj;
+    }
+  }
+#if EXTRA_VERBOSE > 0
+  scs_printf("mult By A time: %1.2es\n", SCS(tocq)(&mult_by_a_timer) / 1e3);
+#endif
+}

data/vendor/scs/linsys/amatrix.h

@@ -0,0 +1,36 @@
+#ifndef AMATRIX_H_GUARD
+#define AMATRIX_H_GUARD
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "glbopts.h"
+#include "linalg.h"
+#include "linsys.h"
+#include "scs.h"
+#include "util.h"
+
+/* this struct defines the data matrix A */
+struct SCS_A_DATA_MATRIX {
+  /* A is supplied in column compressed format */
+  scs_float *x; /* A values, size: NNZ A */
+  scs_int *i;   /* A row index, size: NNZ A */
+  scs_int *p;   /* A column pointer, size: n+1 */
+  scs_int m, n; /* m rows, n cols */
+};
+
+void SCS(_accum_by_atrans)(scs_int n, scs_float *Ax, scs_int *Ai, scs_int *Ap,
+                           const scs_float *x, scs_float *y);
+void SCS(_accum_by_a)(scs_int n, scs_float *Ax, scs_int *Ai, scs_int *Ap,
+                      const scs_float *x, scs_float *y);
+void SCS(_normalize_a)(ScsMatrix *A, const ScsSettings *stgs, const ScsCone *k,
+                       ScsScaling *scal);
+void SCS(_un_normalize_a)(ScsMatrix *A, const ScsSettings *stgs,
+                          const ScsScaling *scal);
+scs_float SCS(cumsum)(scs_int *p, scs_int *c, scs_int n);
+
+#ifdef __cplusplus
+}
+#endif
+#endif