scs 0.2.1 → 0.3.1

data/vendor/scs/Makefile

@@ -1,7 +1,9 @@
 # MAKEFILE for scs
 include scs.mk
 
-SCS_OBJECTS = src/scs.o src/util.o src/cones.o src/aa.o src/rw.o src/linalg.o src/ctrlc.o src/scs_version.o src/normalize.o
+SCS_OBJECTS = src/util.o src/cones.o src/aa.o src/rw.o src/linalg.o src/ctrlc.o src/scs_version.o src/normalize.o
+SCS_O = src/scs.o
+SCS_INDIR_O = src/scs_indir.o
 
 SRC_FILES = $(wildcard src/*.c)
 INC_FILES = $(wildcard include/*.h)
@@ -17,7 +19,7 @@ TARGETS = $(OUT)/demo_socp_indirect $(OUT)/demo_socp_direct $(OUT)/run_from_file
 default: $(TARGETS) $(OUT)/libscsdir.a $(OUT)/libscsindir.a $(OUT)/libscsdir.$(SHARED) $(OUT)/libscsindir.$(SHARED)
 	@echo "****************************************************************************************"
 	@echo "Successfully compiled scs, copyright Brendan O'Donoghue 2012."
-	@echo "To test, type '$(OUT)/demo_socp_indirect' to solve a random SOCP."
+	@echo "To test, type '$(OUT)/demo_socp_direct' to solve a random SOCP."
 	@echo "**********************************************************************************"
 ifneq ($(USE_LAPACK), 0)
 	@echo "Compiled with blas and lapack, can solve LPs, SOCPs, SDPs, ECPs, and PCPs"
@@ -28,38 +30,43 @@ else
 endif
 	@echo "****************************************************************************************"
 
+$(SCS_O): src/scs.c $(INC_FILES)
+	$(CC) $(CFLAGS) -c $< -o $@
+
+$(SCS_INDIR_O): src/scs.c $(INC_FILES)
+	$(CC) $(CFLAGS) -DINDIRECT=1 -c $< -o $@
+
 %.o : src/%.c
 	$(CC) $(CFLAGS) -c $< -o $@
 
-src/scs.o	: $(SRC_FILES) $(INC_FILES)
 src/util.o	: src/util.c include/util.h include/glbopts.h
 src/cones.o	: src/cones.c include/cones.h include/scs_blas.h
 src/aa.o	: src/aa.c include/aa.h include/scs_blas.h
 src/rw.o	: src/rw.c include/rw.h
-src/cs.o	: src/cs.c include/cs.h
 src/linalg.o: src/linalg.c include/linalg.h
 src/ctrl.o  : src/ctrl.c include/ctrl.h
 src/scs_version.o: src/scs_version.c include/glbopts.h
 
 $(DIRSRC)/private.o: $(DIRSRC)/private.c  $(DIRSRC)/private.h
 $(INDIRSRC)/indirect/private.o: $(INDIRSRC)/private.c $(INDIRSRC)/private.h
-$(LINSYS)/amatrix.o: $(LINSYS)/amatrix.c $(LINSYS)/amatrix.h
+$(LINSYS)/scs_matrix.o: $(LINSYS)/scs_matrix.c $(LINSYS)/scs_matrix.h
+$(LINSYS)/csparse.o: $(LINSYS)/csparse.c $(LINSYS)/csparse.h
 
-$(OUT)/libscsdir.a: $(SCS_OBJECTS) $(DIRSRC)/private.o $(AMD_OBJS) $(LDL_OBJS) $(LINSYS)/amatrix.o
+$(OUT)/libscsdir.a: $(SCS_O) $(SCS_OBJECTS) $(DIRSRC)/private.o $(AMD_OBJS) $(LDL_OBJS) $(LINSYS)/scs_matrix.o $(LINSYS)/csparse.o
 	mkdir -p $(OUT)
 	$(ARCHIVE) $@ $^
 	- $(RANLIB) $@
 
-$(OUT)/libscsindir.a: $(SCS_OBJECTS) $(INDIRSRC)/private.o $(LINSYS)/amatrix.o
+$(OUT)/libscsindir.a: $(SCS_INDIR_O) $(SCS_OBJECTS) $(INDIRSRC)/private.o $(LINSYS)/scs_matrix.o $(LINSYS)/csparse.o
 	mkdir -p $(OUT)
 	$(ARCHIVE) $@ $^
 	- $(RANLIB) $@
 
-$(OUT)/libscsdir.$(SHARED): $(SCS_OBJECTS) $(DIRSRC)/private.o $(AMD_OBJS) $(LDL_OBJS) $(LINSYS)/amatrix.o
+$(OUT)/libscsdir.$(SHARED): $(SCS_O) $(SCS_OBJECTS) $(DIRSRC)/private.o $(AMD_OBJS) $(LDL_OBJS) $(LINSYS)/scs_matrix.o $(LINSYS)/csparse.o
 	mkdir -p $(OUT)
 	$(CC) $(CFLAGS) -shared -Wl,$(SONAME),$(@:$(OUT)/%=%) -o $@ $^ $(LDFLAGS)
 
-$(OUT)/libscsindir.$(SHARED): $(SCS_OBJECTS) $(INDIRSRC)/private.o $(LINSYS)/amatrix.o
+$(OUT)/libscsindir.$(SHARED): $(SCS_INDIR_O) $(SCS_OBJECTS) $(INDIRSRC)/private.o $(LINSYS)/scs_matrix.o $(LINSYS)/csparse.o
 	mkdir -p $(OUT)
 	$(CC) $(CFLAGS) -shared -Wl,$(SONAME),$(@:$(OUT)/%=%) -o $@ $^ $(LDFLAGS)
 
@@ -110,20 +117,20 @@ $(LINSYS)/gpu/gpu.o: $(LINSYS)/gpu/gpu.c
 $(GPUINDIR)/private.o: $(GPUINDIR)/private.c
 	$(CUCC) -c -o $(GPUINDIR)/private.o $^ $(CUDAFLAGS)
 
-# $(OUT)/libscsgpudir.$(SHARED): $(SCS_OBJECTS) $(GPUDIR)/private.o $(AMD_OBJS) $(LINSYS)/amatrix.o $(LINSYS)/gpu/gpu.o
+# $(OUT)/libscsgpudir.$(SHARED): $(SCS_O) $(SCS_OBJECTS) $(GPUDIR)/private.o $(AMD_OBJS) $(LINSYS)/scs_matrix.o $(LINSYS)/gpu/gpu.o
 #	 mkdir -p $(OUT)
 # 	$(CC) $(CFLAGS) -shared -Wl,$(SONAME),$(@:$(OUT)/%=%) -o $@ $^ $(LDFLAGS) $(CULDFLAGS)
 
-# $(OUT)/libscsgpudir.a: $(SCS_OBJECTS) $(GPUDIR)/private.o $(AMD_OBJS) $(LINSYS)/amatrix.o $(LINSYS)/gpu/gpu.o
+# $(OUT)/libscsgpudir.a: $(SCS_INDIR_O) $(SCS_OBJECTS) $(GPUDIR)/private.o $(AMD_OBJS) $(LINSYS)/scs_matrix.o $(LINSYS)/gpu/gpu.o
 #  	mkdir -p $(OUT)
 # 	$(ARCHIVE) $@ $^
 # 	- $(RANLIB) $@
 
-$(OUT)/libscsgpuindir.$(SHARED): $(SCS_OBJECTS) $(GPUINDIR)/private.o $(LINSYS)/amatrix.o $(LINSYS)/gpu/gpu.o
+$(OUT)/libscsgpuindir.$(SHARED): $(SCS_O) $(SCS_OBJECTS) $(GPUINDIR)/private.o $(LINSYS)/scs_matrix.o $(LINSYS)/csparse.o $(LINSYS)/gpu/gpu.o
 	mkdir -p $(OUT)
 	$(CC) $(CFLAGS) -shared -Wl,$(SONAME),$(@:$(OUT)/%=%) -o $@ $^ $(LDFLAGS) $(CULDFLAGS)
 
-$(OUT)/libscsgpuindir.a: $(SCS_OBJECTS) $(GPUINDIR)/private.o $(LINSYS)/amatrix.o $(LINSYS)/gpu/gpu.o
+$(OUT)/libscsgpuindir.a: $(SCS_INDIR_O) $(SCS_OBJECTS) $(GPUINDIR)/private.o $(LINSYS)/scs_matrix.o $(LINSYS)/csparse.o $(LINSYS)/gpu/gpu.o
 	mkdir -p $(OUT)
 	$(ARCHIVE) $@ $^
 	- $(RANLIB) $@
@@ -136,7 +143,7 @@ $(OUT)/demo_socp_gpu_indirect: test/random_socp_prob.c $(OUT)/libscsgpuindir.a
 
 .PHONY: clean purge
 clean:
-	@rm -rf $(TARGETS) $(SCS_OBJECTS) $(AMD_OBJS) $(LDL_OBJS) $(LINSYS)/*.o $(DIRSRC)/*.o $(INDIRSRC)/*.o $(GPUDIR)/*.o $(GPUINDIR)/*.o
+	@rm -rf $(TARGETS) $(SCS_O) $(SCS_INDIR_O) $(SCS_OBJECTS) $(AMD_OBJS) $(LDL_OBJS) $(LINSYS)/*.o $(DIRSRC)/*.o $(INDIRSRC)/*.o $(GPUDIR)/*.o $(GPUINDIR)/*.o
 	@rm -rf $(OUT)/*.dSYM
 	@rm -rf matlab/*.mex*
 	@rm -rf .idea
@@ -153,7 +160,7 @@ INSTALL_GPU_TARGETS = $(OUT)/libscsgpuindir.a $(OUT)/libscsgpuindir.$(SHARED) #
 INSTALL_INC_DIR = $(DESTDIR)$(PREFIX)/include/scs/
 INSTALL_LIB_DIR = $(DESTDIR)$(PREFIX)/lib/
 
-.PHONY: install install_gpu
+.PHONY: install install_gpu direct indirect
 install: $(INSTALL_INC_FILES) $(INSTALL_TARGETS)
 	$(INSTALL) -d $(INSTALL_INC_DIR) $(INSTALL_LIB_DIR)
 	$(INSTALL) -m 644 $(INSTALL_INC_FILES) $(INSTALL_INC_DIR)
@@ -162,3 +169,5 @@ install_gpu: $(INSTALL_INC_FILES) $(INSTALL_GPU_TARGETS)
 	$(INSTALL) -d $(INSTALL_INC_DIR) $(INSTALL_LIB_DIR)
 	$(INSTALL) -m 644 $(INSTALL_INC_FILES) $(INSTALL_INC_DIR)
 	$(INSTALL) -m 644 $(INSTALL_GPU_TARGETS) $(INSTALL_LIB_DIR)
+direct:$(OUT)/libscsdir.$(SHARED) $(OUT)/demo_socp_direct $(OUT)/run_from_file_direct $(OUT)/run_tests_direct
+indirect:$(OUT)/libscsindir.$(SHARED) $(OUT)/demo_socp_indirect $(OUT)/run_from_file_indirect $(OUT)/run_tests_indirect

data/vendor/scs/README.md

@@ -1,220 +1,12 @@
-SCS
-====
+<h1 align="center" margin=0px>
+<img src="https://github.com/cvxgrp/scs/blob/master/docs/src/_static/scs_logo.png" alt="Intersection of a cone and a polyhedron" width="450">
+</h1>
 
-[![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)
+[![Build Status](https://github.com/cvxgrp/scs/actions/workflows/build.yml/badge.svg)](https://github.com/cvxgrp/scs/actions/workflows/build.yml)
+[![Coverage Status](https://coveralls.io/repos/github/cvxgrp/scs/badge.svg?branch=master)](https://coveralls.io/github/cvxgrp/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**
+SCS (`splitting conic solver`) is a numerical optimization package for solving
+large-scale convex cone problems. The current version is `3.0.0`.
 
-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.
+The full documentation is available [here](https://www.cvxgrp.org/scs/).

data/vendor/scs/include/aa.h

@@ -5,50 +5,94 @@
 extern "C" {
 #endif
 
+#include "glbopts.h"
 #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.
+/**
+ * Initialize Anderson Acceleration, allocates memory.
+ *
+ * @param dim               the dimension of the variable for AA
+ * @param mem               the memory (number of past iterations used) for AA
+ * @param type1             if True use type 1 AA, otherwise use type 2
+ * @param regularization    type-I and type-II different, for type-I: 1e-8 works
+ *                          well, type-II: more stable can use 1e-12 often
+ * @param relaxation        float \in [0,2], mixing parameter (1.0 is vanilla)
+ * @param safeguard_factor  factor that controls safeguarding checks
+ *                          larger is more aggressive but less stable
+ * @param max_weight_norm   float, maximum norm of AA weights
+ * @param verbosity         if greater than 0 prints out various info
+ *
+ * @return pointer to AA workspace
+ *
+ */
+AaWork *aa_init(aa_int dim, aa_int mem, aa_int type1, aa_float regularization,
+                aa_float relaxation, aa_float safeguard_factor,
+                aa_float max_weight_norm, aa_int verbosity);
+/**
+ * Apply Anderson Acceleration. The usage pattern should be as follows:
+ *
+ * - for i = 0 .. N:
+ *    -  if (i > 0): aa_apply(x, x_prev, a)
+ *    -  x_prev = x.copy()
+ *    -  x = F(x)
+ *    -  aa_safeguard(x, x_prev, a)  // optional but helps stability
+ *
+ *  Here F is the map we are trying to find the fixed point for. We put the AA
+ *  before the map so that any properties of the map are maintained at the end.
+ *  Eg if the map contains a projection onto a set then the output is guaranteed
+ *  to be in the set.
+ *
  *
- * 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
+ * @param f   output of map at current iteration, overwritten with AA output
+ * @param x   input to map at current iteration
+ * @param a   workspace from aa_init
+ *
+ * @return (+ or -) norm of AA weights vector. If positive then update
+ *         was accepted and f contains new point, if negative then update was
+ *         rejected and f is unchanged
  *
- * Reurns:
- *  Pointer to aa workspace
  */
-AaWork *aa_init(aa_int dim, aa_int aa_mem, aa_int type1);
+aa_float aa_apply(aa_float *f, const aa_float *x, AaWork *a);
 
-/* Apply Anderson Acceleration.
+/**
+ * Apply safeguarding.
+ *
+ * This step is optional but can improve stability.
+ *
+ * @param f_new  output of map after AA step
+ * @param x_new  AA output that is input to the map
+ * @param a      workspace from aa_init
  *
- * 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 0 if AA step is accepted otherwise -1, if AA step is rejected then
+ *          this overwrites f_new and x_new with previous values
  *
- * 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);
+aa_int aa_safeguard(aa_float *f_new, aa_float *x_new, AaWork *a);
 
-/* Finish Anderson Acceleration, clears memory.
+/**
+ * Finish Anderson Acceleration, clears memory.
+ *
+ * @param a   AA workspace from aa_init
  *
- * 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))
+/**
+ * Reset Anderson Acceleration.
+ *
+ * Resets AA as if at the first iteration, reuses original memory allocations.
+ *
+ * @param a   AA workspace from aa_init
+ *
+ */
+void aa_reset(AaWork *a);
 
 #ifdef __cplusplus
 }

data/vendor/scs/include/cones.h

@@ -11,34 +11,34 @@ extern "C" {
 
 /* private data to help cone projection step */
 struct SCS_CONE_WORK {
-  scs_float total_cone_time;
+  /*
+   * cone_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
+   */
+  scs_float *s; /* used for Moreau decomposition in projection */
+  scs_int cone_len;
+  /* box cone quantities */
+  scs_float *bl, *bu, box_t_warm_start;
 #ifdef USE_LAPACK
   /* workspace for eigenvector decompositions: */
   scs_float *Xs, *Z, *e, *work;
-  blas_int *iwork, lwork, liwork;
+  blas_int lwork;
 #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);
+ScsConeWork *SCS(init_cone)(const ScsCone *k, const ScsScaling *scal,
+                            scs_int cone_len);
 char *SCS(get_cone_header)(const ScsCone *k);
 scs_int SCS(validate_cones)(const ScsData *d, const ScsCone *k);
+scs_int SCS(set_cone_boundaries)(const ScsCone *k, scs_int **cone_boundaries);
 
-/* 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);
+                            scs_int normalize);
 void SCS(finish_cone)(ScsConeWork *c);
-char *SCS(get_cone_summary)(const ScsInfo *info, ScsConeWork *c);
+
+void SCS(set_rho_y_vec)(const ScsCone *k, scs_float scale, scs_float *rho_y_vec,
+                        scs_int m);
 
 #ifdef __cplusplus
 }