scs 0.2.0

data/vendor/scs/README.md

@@ -0,0 +1,220 @@
+SCS
+====
+
+[![Build Status](https://travis-ci.org/cvxgrp/scs.svg?branch=master)](https://travis-ci.org/cvxgrp/scs)
+[![Build status](https://ci.appveyor.com/api/projects/status/4542u6kom5293qpm/branch/master?svg=true)](https://ci.appveyor.com/project/bodono/scs/branch/master)
+
+SCS (`splitting conic solver`) is a numerical optimization package for solving
+large-scale convex cone problems, based on our paper [Conic Optimization via
+Operator Splitting and Homogeneous Self-Dual
+Embedding](http://www.stanford.edu/~boyd/papers/scs.html). It is written in C
+and can be used in other C, C++,
+[Python](https://github.com/bodono/scs-python),
+[Matlab](https://github.com/bodono/scs-matlab),
+[R](https://github.com/bodono/scs-r),
+[Julia](https://github.com/JuliaOpt/SCS.jl), programs via the linked
+interfaces. It can also be called as a solver from convex optimization
+toolboxes [CVX](http://cvxr.com/cvx/) (3.0 or later),
+[CVXPY](https://github.com/cvxgrp/cvxpy),
+[Convex.jl](https://github.com/JuliaOpt/Convex.jl), and
+[Yalmip](https://github.com/johanlofberg/YALMIP).
+
+The current version is `2.1.2`. If you wish to cite SCS, please use the
+following:
+```
+@article{ocpb:16,
+    author       = {B. O'Donoghue and E. Chu and N. Parikh and S. Boyd},
+    title        = {Conic Optimization via Operator Splitting and Homogeneous Self-Dual Embedding},
+    journal      = {Journal of Optimization Theory and Applications},
+    month        = {June},
+    year         = {2016},
+    volume       = {169},
+    number       = {3},
+    pages        = {1042-1068},
+    url          = {http://stanford.edu/~boyd/papers/scs.html},
+}
+@misc{scs,
+    author       = {B. O'Donoghue and E. Chu and N. Parikh and S. Boyd},
+    title        = {{SCS}: Splitting Conic Solver, version 2.1.2},
+    howpublished = {\url{https://github.com/cvxgrp/scs}},
+    month        = nov,
+    year         = 2019
+}
+```
+
+----
+SCS numerically solves convex cone programs using the alternating direction
+method of multipliers
+([ADMM](http://web.stanford.edu/~boyd/papers/admm_distr_stats.html)).  It
+returns solutions to both the primal and dual problems if the problem is
+feasible, or a certificate of infeasibility otherwise. It solves the following
+primal cone problem:
+
+```
+minimize        c'x
+subject to      Ax + s = b
+                s in K
+```
+over variables `x` and `s`, where `A`, `b` and `c` are user-supplied data and
+`K` is a user-defined convex cone.  The dual problem is given by
+```
+maximize        -b'y
+subject to      -A'y == c
+                y in K^*
+```
+over variable `y`, where `K^*` denotes the dual cone to `K`.
+
+The cone `K` can be any Cartesian product of the following primitive cones:
++ zero cone `{x | x = 0 }` (dual to the free cone `{x | x in R}`)
++ positive orthant `{x | x >= 0}`
++ second-order cone `{(t,x) | ||x||_2 <= t}`
++ positive semidefinite cone `{ X | min(eig(X)) >= 0, X = X^T }`
++ exponential cone `{(x,y,z) | y e^(x/y) <= z, y>0 }`
++ dual exponential cone `{(u,v,w) | −u e^(v/u) <= e w, u<0}`
++ power cone `{(x,y,z) | x^a * y^(1-a) >= |z|, x>=0, y>=0}`
++ dual power cone `{(u,v,w) | (u/a)^a * (v/(1-a))^(1-a) >= |w|, u>=0, v>=0}`
+
+The rows of the data matrix `A` correspond to the cones in `K`.  **The rows of
+`A` must be in the order of the cones given above, i.e., first come the rows
+that correspond to the zero/free cones, then those that correspond to the
+positive orthants, then SOCs, etc.** For a `k` dimensional semidefinite cone
+when interpreting the rows of the data matrix `A` SCS assumes that the `k x k`
+matrix variable has been vectorized by scaling the off-diagonal entries by
+`sqrt(2)` and stacking the **lower triangular elements column-wise** to create a
+vector of length `k(k+1)/2`. See the section on semidefinite programming below.
+
+At termination SCS returns solution `(x*, s*, y*)` if the problem is feasible,
+or a certificate of infeasibility otherwise. See
+[here](http://web.stanford.edu/~boyd/cvxbook/) for more details about
+cone programming and certificates of infeasibility.
+
+**Anderson Acceleration**
+
+By default SCS uses Anderson acceleration (AA) to speed up convergence. The
+number of iterates that SCS uses in the AA calculation can be controlled by the
+parameter `acceleration_lookback` in the settings struct. It defaults to 10.  AA
+is available as a standalone package [here](https://github.com/cvxgrp/aa).  More
+details are available in our paper on AA
+[here](https://stanford.edu/~boyd/papers/nonexp_global_aa1.html).
+
+**Semidefinite Programming**
+
+SCS assumes that the matrix variables and the input data corresponding to
+semidefinite cones have been vectorized by **scaling the off-diagonal entries by
+`sqrt(2)`** and stacking the lower triangular elements **column-wise**. For a `k
+x k` matrix variable (or data matrix) this operation would create a vector of
+length `k(k+1)/2`. Scaling by `sqrt(2)` is required to preserve the
+inner-product.
+
+**To recover the matrix solution this operation must be inverted on the
+components of the vector returned by SCS corresponding to semidefinite cones**.
+That is, the off-diagonal entries must be scaled by `1/sqrt(2)` and the upper
+triangular entries are filled in by copying the values of lower triangular
+entries.
+
+More explicitly, we want to express
+`Tr(C X)` as `vec(C)'*vec(X)`, where the `vec` operation takes the `k x k` matrix
+```
+X = [ X11 X12 ... X1k
+      X21 X22 ... X2k
+      ...
+      Xk1 Xk2 ... Xkk ]
+```
+and produces a vector consisting of
+```
+vec(X) = (X11, sqrt(2)*X21, ..., sqrt(2)*Xk1, X22, sqrt(2)*X32, ..., Xkk).
+```
+
+**Linear equation solvers**
+
+Each iteration of SCS requires the solution of a set of linear equations.  This
+package includes two implementations for solving linear equations: a direct
+solver which uses a cached LDL factorization and an indirect solver based on
+conjugate gradients. The indirect solver can be run on either the cpu or
+gpu.
+
+The direct solver uses external numerical linear algebra packages:
+* [QDLDL](https://github.com/oxfordcontrol/qdldl)
+* [AMD](http://www.cise.ufl.edu/research/sparse/).
+
+### Using SCS in C
+Typing `make` at the command line will compile the code and create SCS libraries
+in the `out` folder. To run the tests execute:
+```sh
+make
+make test
+test/run_tests
+```
+
+If `make` completes successfully, it will produce two static library files,
+`libscsdir.a`, `libscsindir.a`, and two dynamic library files `libscsdir.ext`,
+`libscsindir.ext` (where `.ext` extension is platform dependent) in the same
+folder. It will also produce two demo binaries in the `out` folder named
+`demo_socp_direct`, and `demo_socp_indirect`. If you have a GPU and have CUDA
+installed, you can also execture `make gpu` to compile SCS to run on the GPU
+which will create additional libraries and demo binaries in the `out` folder
+corresponding to the gpu version. Note that the GPU version requires 32 bit
+ints, which can be enforced by compiling with `DLONG=0`.
+
+To use the libraries in your own source code, compile your code with the linker
+option `-L(PATH_TO_SCS_LIBS)` and `-lscsdir` or `-lscsindir` (as needed).  The
+API and required data structures are defined in the file `include/scs.h`.  The
+four main API functions are:
+
+* `ScsWork * scs_init(const ScsData * d, const ScsCone * k, ScsInfo * info);`
+
+    This initializes the ScsWork struct containing the workspace that scs will
+    use, and performs the necessary preprocessing (e.g. matrix factorization).
+    All inputs `d`, `k`, and `info` must be memory allocated before calling.
+
+* `scs_int scs_solve(ScsWork * w, const ScsData * d, const ScsCone * k, ScsSolution * sol, ScsInfo * info);`
+
+    This solves the problem as defined by ScsData `d` and ScsCone `k` using the
+    workspace in `w`. The solution is returned in `sol` and information about
+    the solve is returned in `info` (outputs must have memory allocated before
+    calling).  None of the inputs can be NULL. You can call `scs_solve` many
+    times for one call to `scs_init`, so long as the matrix `A` does not change
+    (vectors `b` and `c` can change).
+
+* `void scs_finish(ScsWork * w);`
+
+    Called after all solves completed to free allocated memory and other
+    cleanup.
+
+* `scs_int scs(const ScsData * d, const ScsCone * k, ScsSolution * sol, ScsInfo * info);`
+
+    Convenience method that simply calls all the above routines in order, for
+    cases where the workspace does not need to be reused. All inputs must have
+    memory allocated before this call.
+
+The data matrix `A` is specified in column-compressed format and the vectors `b`
+and `c` are specified as dense arrays. The solutions `x` (primal), `s` (slack),
+and `y` (dual) are returned as dense arrays. Cones are specified as the struct
+defined in `include/scs.h`, the rows of `A` must correspond to the cones in the
+exact order as specified by the cone struct (i.e. put linear cones before
+second-order cones etc.).
+
+**Warm-start**
+
+You can warm-start SCS (supply a guess of the solution) by setting `warm_start`
+in the ScsData struct to `1` and supplying the warm-starts in the ScsSolution
+struct (`x`,`y`, and `s`). All inputs must be warm-started if any one is. These
+are used to initialize the iterates in `scs_solve`.
+
+**Re-using matrix factorization**
+
+If using the direct version you can factorize the matrix once and solve many
+times. Simply call `scs_init` once, and use `scs_solve` many times with the same
+workspace, changing the input data `b` and `c` (and optionally warm-starts) for
+each iteration.
+
+**Using your own linear system solver**
+
+To use your own linear system solver simply implement all the methods and the
+two structs in `include/linsys.h` and plug it in.
+
+**BLAS / LAPACK install error**
+
+If you get an error like `cannot find -lblas` or `cannot find -llapack`, then
+you need to install blas and lapack and / or update your environment variables
+to point to the install locations.

data/vendor/scs/include/aa.h

@@ -0,0 +1,56 @@
+#ifndef AA_H_GUARD
+#define AA_H_GUARD
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "glbopts.h"
+
+typedef scs_float aa_float;
+typedef scs_int aa_int;
+
+typedef struct ACCEL_WORK AaWork;
+
+/* Initialize Anderson Acceleration, allocates memory.
+ *
+ * Args:
+ *  dim: the dimension of the variable for aa
+ *  aa_mem: the memory (number of past iterations used) for aa
+ *  type1: bool, if True use type 1 aa, otherwise use type 2
+ *
+ * Reurns:
+ *  Pointer to aa workspace
+ */
+AaWork *aa_init(aa_int dim, aa_int aa_mem, aa_int type1);
+
+/* Apply Anderson Acceleration.
+ *
+ * Args:
+ *  f: output of map at current iteration, overwritten with aa output at end.
+ *  x: input to map at current iteration
+ *  a: aa workspace from aa_init
+ *
+ * Returns:
+ *  int, a value of 0 is success, <0 is failure at which point f is unchanged
+ */
+aa_int aa_apply(aa_float *f, const aa_float *x, AaWork *a);
+
+/* Finish Anderson Acceleration, clears memory.
+ *
+ * Args:
+ *  a: aa workspace from aa_init.
+ */
+void aa_finish(AaWork *a);
+
+#define MAX_AA_NRM (1e4)
+
+#define MIN(a, b) (((a) < (b)) ? (a) : (b))
+
+#ifdef __cplusplus
+}
+#endif
+#endif

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