scs 0.2.2

data/vendor/scs/include/cones.h

@@ -0,0 +1,46 @@
+#ifndef CONES_H_GUARD
+#define CONES_H_GUARD
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "glbopts.h"
+#include "scs.h"
+#include "scs_blas.h"
+
+/* private data to help cone projection step */
+struct SCS_CONE_WORK {
+  scs_float total_cone_time;
+#ifdef USE_LAPACK
+  /* workspace for eigenvector decompositions: */
+  scs_float *Xs, *Z, *e, *work;
+  blas_int *iwork, lwork, liwork;
+#endif
+};
+
+/*
+ * boundaries will contain array of indices of rows of A corresponding to
+ * cone boundaries, boundaries[0] is starting index for cones of size larger
+ * than 1
+ * returns length of boundaries array, boundaries malloc-ed here so should be
+ * freed
+ */
+scs_int SCS(get_cone_boundaries)(const ScsCone *k, scs_int **boundaries);
+
+ScsConeWork *SCS(init_cone)(const ScsCone *k);
+char *SCS(get_cone_header)(const ScsCone *k);
+scs_int SCS(validate_cones)(const ScsData *d, const ScsCone *k);
+
+/* pass in iter to control how accurate the cone projection
+ with iteration, set iter < 0 for exact projection, warm_start contains guess
+ of solution, can be SCS_NULL*/
+scs_int SCS(proj_dual_cone)(scs_float *x, const ScsCone *k, ScsConeWork *c,
+                            const scs_float *warm_start, scs_int iter);
+void SCS(finish_cone)(ScsConeWork *c);
+char *SCS(get_cone_summary)(const ScsInfo *info, ScsConeWork *c);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

data/vendor/scs/include/ctrlc.h

@@ -0,0 +1,33 @@
+/*
+ * Interface for SCS signal handling.
+ */
+
+#ifndef CTRLC_H_GUARD
+#define CTRLC_H_GUARD
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if CTRLC > 0
+
+void scs_start_interrupt_listener(void);
+void scs_end_interrupt_listener(void);
+int scs_is_interrupted(void);
+
+#else /* CTRLC = 0 */
+
+/* Simply to suppress empty translation unit warnings. */
+typedef int scs_make_iso_compilers_happy;
+
+/* No signal handling. */
+#define scs_start_interrupt_listener()
+#define scs_end_interrupt_listener()
+#define scs_is_interrupted() 0
+
+#endif /* END IF CTRLC > 0 */
+
+#ifdef __cplusplus
+}
+#endif
+#endif

data/vendor/scs/include/glbopts.h

@@ -0,0 +1,177 @@
+#ifndef GLB_H_GUARD
+#define GLB_H_GUARD
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <math.h>
+
+#ifndef SCS
+#define SCS(x) scs_##x
+#endif
+
+/* SCS VERSION NUMBER ----------------------------------------------    */
+#define SCS_VERSION \
+  ("2.1.2") /* string literals automatically null-terminated */
+
+/* SCS returns one of the following integers:                           */
+#define SCS_INFEASIBLE_INACCURATE (-7)
+#define SCS_UNBOUNDED_INACCURATE (-6)
+#define SCS_SIGINT (-5)
+#define SCS_FAILED (-4)
+#define SCS_INDETERMINATE (-3)
+#define SCS_INFEASIBLE (-2) /* primal infeasible, dual unbounded   */
+#define SCS_UNBOUNDED (-1)  /* primal unbounded, dual infeasible   */
+#define SCS_UNFINISHED (0)  /* never returned, used as placeholder */
+#define SCS_SOLVED (1)
+#define SCS_SOLVED_INACCURATE (2)
+
+/* DEFAULT SOLVER PARAMETERS AND SETTINGS --------------------------    */
+#define MAX_ITERS (5000)
+#define EPS (1E-5)
+#define ALPHA (1.5)
+#define RHO_X (1E-3)
+#define SCALE (1.0)
+#define CG_RATE (2.0)
+#define VERBOSE (1)
+#define NORMALIZE (1)
+#define WARM_START (0)
+#define ACCELERATION_LOOKBACK (10)
+#define WRITE_DATA_FILENAME (0)
+
+/* redefine printfs and memory allocators as needed */
+#ifdef MATLAB_MEX_FILE
+#include "mex.h"
+#define scs_printf mexPrintf
+#define _scs_free mxFree
+#define _scs_malloc mxMalloc
+#define _scs_calloc mxCalloc
+#define _scs_realloc mxRealloc
+#elif defined PYTHON
+#include <Python.h>
+#include <stdlib.h>
+#define scs_printf(...)                              \
+  {                                                  \
+    PyGILState_STATE gilstate = PyGILState_Ensure(); \
+    PySys_WriteStdout(__VA_ARGS__);                  \
+    PyGILState_Release(gilstate);                    \
+  }
+#define _scs_printf printf
+#define _scs_free free
+#define _scs_malloc malloc
+#define _scs_calloc calloc
+#define _scs_realloc realloc
+#elif (defined(USING_R))
+#include <R_ext/Print.h> /* Rprintf etc */
+#include <stdio.h>
+#include <stdlib.h>
+#define scs_printf Rprintf
+#define _scs_free free
+#define _scs_malloc malloc
+#define _scs_calloc calloc
+#define _scs_realloc realloc
+#else
+#include <stdio.h>
+#include <stdlib.h>
+#define scs_printf printf
+#define _scs_free free
+#define _scs_malloc malloc
+#define _scs_calloc calloc
+#define _scs_realloc realloc
+#endif
+
+/* Only required for SuiteSparse compatibility: */
+#ifndef _scs_printf
+#define _scs_printf scs_printf
+#endif
+
+#define scs_free(x) \
+  _scs_free(x);     \
+  x = SCS_NULL
+#define scs_malloc(x) _scs_malloc(x)
+#define scs_calloc(x, y) _scs_calloc(x, y)
+#define scs_realloc(x, y) _scs_realloc(x, y)
+
+#ifdef DLONG
+#ifdef _WIN64
+#include <stdint.h>
+typedef int64_t scs_int;
+/* typedef long scs_int; */
+#else
+typedef long scs_int;
+#endif
+#else
+typedef int scs_int;
+#endif
+
+#ifndef SFLOAT
+typedef double scs_float;
+#ifndef NAN
+#define NAN ((scs_float)0x7ff8000000000000)
+#endif
+#ifndef INFINITY
+#define INFINITY NAN
+#endif
+#else
+typedef float scs_float;
+#ifndef NAN
+#define NAN ((float)0x7fc00000)
+#endif
+#ifndef INFINITY
+#define INFINITY NAN
+#endif
+#endif
+
+#define SCS_NULL 0
+
+#ifndef MAX
+#define MAX(a, b) (((a) > (b)) ? (a) : (b))
+#endif
+
+#ifndef MIN
+#define MIN(a, b) (((a) < (b)) ? (a) : (b))
+#endif
+
+#ifndef ABS
+#define ABS(x) (((x) < 0) ? -(x) : (x))
+#endif
+
+#ifndef POWF
+#ifdef SFLOAT
+#define POWF powf
+#else
+#define POWF pow
+#endif
+#endif
+
+#ifndef SQRTF
+#ifdef SFLOAT
+#define SQRTF sqrtf
+#else
+#define SQRTF sqrt
+#endif
+#endif
+
+#define EPS_TOL (1E-18)
+#define SAFEDIV_POS(X, Y) ((Y) < EPS_TOL ? ((X) / EPS_TOL) : (X) / (Y))
+
+#if EXTRA_VERBOSE > 0
+#define PRINT_INTERVAL (1)
+#define CONVERGED_INTERVAL (1)
+#else
+/* print summary output every this num iterations */
+#define PRINT_INTERVAL (100)
+/* check for convergence every this num iterations */
+#define CONVERGED_INTERVAL (20)
+#endif
+
+/* tolerance at which we declare problem indeterminate */
+#define INDETERMINATE_TOL (1e-9)
+/* maintain the iterates at this l2 norm (due to homogeneity) */
+#define ITERATE_NORM (10.)
+
+#ifdef __cplusplus
+}
+#endif
+#endif

data/vendor/scs/include/linalg.h

@@ -0,0 +1,26 @@
+#ifndef LINALG_H_GUARD
+#define LINALG_H_GUARD
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <math.h>
+#include "scs.h"
+
+void SCS(set_as_scaled_array)(scs_float *x, const scs_float *a,
+                              const scs_float b, scs_int len);
+void SCS(scale_array)(scs_float *a, const scs_float b, scs_int len);
+scs_float SCS(dot)(const scs_float *x, const scs_float *y, scs_int len);
+scs_float SCS(norm_sq)(const scs_float *v, scs_int len);
+scs_float SCS(norm)(const scs_float *v, scs_int len);
+scs_float SCS(norm_inf)(const scs_float *a, scs_int l);
+void SCS(add_scaled_array)(scs_float *a, const scs_float *b, scs_int n,
+                           const scs_float sc);
+scs_float SCS(norm_diff)(const scs_float *a, const scs_float *b, scs_int l);
+scs_float SCS(norm_inf_diff)(const scs_float *a, const scs_float *b, scs_int l);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

data/vendor/scs/include/linsys.h

@@ -0,0 +1,64 @@
+#ifndef LINSYS_H_GUARD
+#define LINSYS_H_GUARD
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "scs.h"
+
+/* YOUR LINEAR SYSTEM SOLVER MUST IMPLEMENT THESE METHODS AND SCS_LIN_SYS_WORK
+ * STRUCT */
+
+/* initialize ScsLinSysWork structure and perform any necessary preprocessing */
+ScsLinSysWork *SCS(init_lin_sys_work)(const ScsMatrix *A,
+                                      const ScsSettings *stgs);
+/* solves [d->RHO_X * I  A' ; A  -I] x = b for x, stores result in b, s contains
+ * warm-start, iter is current scs iteration count */
+scs_int SCS(solve_lin_sys)(const ScsMatrix *A, const ScsSettings *stgs,
+                           ScsLinSysWork *p, scs_float *b, const scs_float *s,
+                           scs_int iter);
+/* frees ScsLinSysWork structure and allocated memory in ScsLinSysWork */
+void SCS(free_lin_sys_work)(ScsLinSysWork *p);
+
+/* forms y += A'*x */
+void SCS(accum_by_atrans)(const ScsMatrix *A, ScsLinSysWork *p,
+                          const scs_float *x, scs_float *y);
+/* forms y += A*x */
+void SCS(accum_by_a)(const ScsMatrix *A, ScsLinSysWork *p, const scs_float *x,
+                     scs_float *y);
+
+/* returns negative num if input data is invalid */
+scs_int SCS(validate_lin_sys)(const ScsMatrix *A);
+
+/* returns string describing method, can return null, if not null free will be
+ * called on output */
+char *SCS(get_lin_sys_method)(const ScsMatrix *A, const ScsSettings *stgs);
+/* returns string containing summary information about linear system solves, can
+ * return null, if not null free will be called on output */
+char *SCS(get_lin_sys_summary)(ScsLinSysWork *p, const ScsInfo *info);
+
+/* Normalization routines, used if d->NORMALIZE is true */
+/* normalizes A matrix, sets w->E and w->D diagonal scaling matrices, Anew =
+ * d->SCALE * (D^-1)*A*(E^-1) (different to paper which is D*A*E)
+ * D and E must be all positive entries, D must satisfy cone boundaries
+ * must set (w->mean_norm_row_a = mean of norms of rows of normalized A) THEN
+ * scale
+ * resulting A by d->SCALE */
+void SCS(normalize_a)(ScsMatrix *A, const ScsSettings *stgs, const ScsCone *k,
+                      ScsScaling *scal);
+/* unnormalizes A matrix, unnormalizes by w->D and w->E and d->SCALE */
+void SCS(un_normalize_a)(ScsMatrix *A, const ScsSettings *stgs,
+                         const ScsScaling *scal);
+/* to free the memory allocated in ScsMatrix */
+void SCS(free_a_matrix)(ScsMatrix *A);
+
+/* copies A (instead of in-place normalization), returns 0 for failure,
+ * allocates memory for dstp	*/
+scs_int SCS(copy_a_matrix)(ScsMatrix **dstp, const ScsMatrix *src);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/vendor/scs/include/normalize.h

@@ -0,0 +1,18 @@
+#ifndef NORMALIZE_H_GUARD
+#define NORMALIZE_H_GUARD
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "scs.h"
+
+void SCS(normalize_b_c)(ScsWork *w);
+void SCS(calc_scaled_resids)(ScsWork *w, ScsResiduals *r);
+void SCS(normalize_warm_start)(ScsWork *w);
+void SCS(un_normalize_sol)(ScsWork *w, ScsSolution *sol);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

data/vendor/scs/include/rw.h

@@ -0,0 +1,17 @@
+#ifndef RW_H_GUARD
+#define RW_H_GUARD
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "glbopts.h"
+#include "scs.h"
+
+void SCS(write_data)(const ScsData *d, const ScsCone *k);
+scs_int SCS(read_data)(const char * filename, ScsData **d, ScsCone **k);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

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