scs 0.2.2

data/lib/scs/version.rb

@@ -0,0 +1,3 @@
+module SCS
+  VERSION = "0.2.2"
+end

data/vendor/scs/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2012 Brendan O'Donoghue (bodonoghue85@gmail.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/vendor/scs/Makefile

@@ -0,0 +1,164 @@
+# 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
+
+SRC_FILES = $(wildcard src/*.c)
+INC_FILES = $(wildcard include/*.h)
+
+AMD_SOURCE = $(wildcard $(EXTSRC)/amd/*.c)
+LDL_SOURCE = $(EXTSRC)/qdldl/qdldl.c
+AMD_OBJS = $(AMD_SOURCE:.c=.o)
+LDL_OBJS = $(LDL_SOURCE:.c=.o)
+TARGETS = $(OUT)/demo_socp_indirect $(OUT)/demo_socp_direct $(OUT)/run_from_file_indirect $(OUT)/run_from_file_direct
+
+.PHONY: default
+
+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 "**********************************************************************************"
+ifneq ($(USE_LAPACK), 0)
+	@echo "Compiled with blas and lapack, can solve LPs, SOCPs, SDPs, ECPs, and PCPs"
+else
+	@echo "NOT compiled with blas/lapack, cannot solve SDPs (can solve LPs, SOCPs, ECPs, and PCPs)."
+	@echo "To solve SDPs, install blas and lapack, then edit scs.mk to set USE_LAPACK=1"
+	@echo "and point to the library install locations, and recompile with 'make purge', 'make'."
+endif
+	@echo "****************************************************************************************"
+
+%.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
+
+$(OUT)/libscsdir.a: $(SCS_OBJECTS) $(DIRSRC)/private.o $(AMD_OBJS) $(LDL_OBJS) $(LINSYS)/amatrix.o
+	mkdir -p $(OUT)
+	$(ARCHIVE) $@ $^
+	- $(RANLIB) $@
+
+$(OUT)/libscsindir.a: $(SCS_OBJECTS) $(INDIRSRC)/private.o $(LINSYS)/amatrix.o
+	mkdir -p $(OUT)
+	$(ARCHIVE) $@ $^
+	- $(RANLIB) $@
+
+$(OUT)/libscsdir.$(SHARED): $(SCS_OBJECTS) $(DIRSRC)/private.o $(AMD_OBJS) $(LDL_OBJS) $(LINSYS)/amatrix.o
+	mkdir -p $(OUT)
+	$(CC) $(CFLAGS) -shared -Wl,$(SONAME),$(@:$(OUT)/%=%) -o $@ $^ $(LDFLAGS)
+
+$(OUT)/libscsindir.$(SHARED): $(SCS_OBJECTS) $(INDIRSRC)/private.o $(LINSYS)/amatrix.o
+	mkdir -p $(OUT)
+	$(CC) $(CFLAGS) -shared -Wl,$(SONAME),$(@:$(OUT)/%=%) -o $@ $^ $(LDFLAGS)
+
+$(OUT)/demo_socp_direct: test/random_socp_prob.c $(OUT)/libscsdir.a
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS)
+
+$(OUT)/demo_socp_indirect: test/random_socp_prob.c $(OUT)/libscsindir.a
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS)
+
+$(OUT)/run_from_file_direct: test/run_from_file.c $(OUT)/libscsdir.a
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS)
+
+$(OUT)/run_from_file_indirect: test/run_from_file.c $(OUT)/libscsindir.a
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS)
+
+$(OUT)/run_from_file_gpu_indirect: test/run_from_file.c $(OUT)/libscsgpuindir.a
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(CULDFLAGS)
+
+# basic testing
+.PHONY: test
+test: $(OUT)/run_tests_indirect $(OUT)/run_tests_direct
+$(OUT)/run_tests_indirect: test/run_tests.c $(OUT)/libscsindir.a
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) -Itest
+$(OUT)/run_tests_direct: test/run_tests.c $(OUT)/libscsdir.a
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) -Itest
+
+.PHONY: test_gpu
+test_gpu: $(OUT)/run_tests_gpu_indirect # $(OUT)/run_tests_gpu_direct
+
+$(OUT)/run_tests_gpu_indirect: test/run_tests.c $(OUT)/libscsgpuindir.a
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(CULDFLAGS) -Itest
+
+# $(OUT)/run_tests_gpu_direct: test/run_tests.c $(OUT)/libscsgpudir.a
+# 	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(CULDFLAGS) -Itest
+
+# REQUIRES GPU AND CUDA INSTALLED
+gpu: gpu_indirect # gpu_direct
+
+# gpu_direct: $(OUT)/demo_socp_gpu_direct $(OUT)/libscsgpudir.$(SHARED) $(OUT)/libscsgpudir.a $(OUT)/run_from_file_gpu_direct
+gpu_indirect: $(OUT)/demo_socp_gpu_indirect $(OUT)/libscsgpuindir.$(SHARED) $(OUT)/libscsgpuindir.a $(OUT)/run_from_file_gpu_indirect
+
+$(LINSYS)/gpu/gpu.o: $(LINSYS)/gpu/gpu.c
+	$(CUCC) -c -o $@ $^ $(CUDAFLAGS)
+
+# $(GPUDIR)/private.o: $(GPUDIR)/private.c
+# 	$(CUCC) -c -o $(GPUDIR)/private.o $^ $(CUDAFLAGS)
+
+$(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
+#	 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
+#  	mkdir -p $(OUT)
+# 	$(ARCHIVE) $@ $^
+# 	- $(RANLIB) $@
+
+$(OUT)/libscsgpuindir.$(SHARED): $(SCS_OBJECTS) $(GPUINDIR)/private.o $(LINSYS)/amatrix.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
+	mkdir -p $(OUT)
+	$(ARCHIVE) $@ $^
+	- $(RANLIB) $@
+
+# $(OUT)/demo_socp_gpu_direct: test/random_socp_prob.c $(OUT)/libscsgpudir.a
+# 	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(CULDFLAGS)
+
+$(OUT)/demo_socp_gpu_indirect: test/random_socp_prob.c $(OUT)/libscsgpuindir.a
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(CULDFLAGS)
+
+.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 $(OUT)/*.dSYM
+	@rm -rf matlab/*.mex*
+	@rm -rf .idea
+	@rm -rf python/*.pyc
+	@rm -rf python/build
+purge: clean
+	@rm -rf $(OUT)
+
+INSTALL_INC_FILES = $(INC_FILES)
+
+INSTALL_TARGETS = $(OUT)/libscsdir.a $(OUT)/libscsindir.a $(OUT)/libscsdir.$(SHARED) $(OUT)/libscsindir.$(SHARED)
+INSTALL_GPU_TARGETS = $(OUT)/libscsgpuindir.a $(OUT)/libscsgpuindir.$(SHARED) # $(OUT)/libscsgpudir.a $(OUT)/libscsgpudir.$(SHARED)
+
+INSTALL_INC_DIR = $(DESTDIR)$(PREFIX)/include/scs/
+INSTALL_LIB_DIR = $(DESTDIR)$(PREFIX)/lib/
+
+.PHONY: install install_gpu
+install: $(INSTALL_INC_FILES) $(INSTALL_TARGETS)
+	$(INSTALL) -d $(INSTALL_INC_DIR) $(INSTALL_LIB_DIR)
+	$(INSTALL) -m 644 $(INSTALL_INC_FILES) $(INSTALL_INC_DIR)
+	$(INSTALL) -m 644 $(INSTALL_TARGETS) $(INSTALL_LIB_DIR)
+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)

data/vendor/scs/README.md

@@ -0,0 +1,222 @@
+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), and
+[Ruby](https://github.com/ankane/scs),
+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