scs 0.5.6 → 0.6.0

data/vendor/scs/CONTRIBUTING.md

@@ -0,0 +1,49 @@
+# Contributing to SCS
+
+Thank you for your interest in contributing to SCS! For detailed guidelines,
+see the [contribution docs](https://www.cvxgrp.org/scs/contributing).
+
+## Quick Start
+
+```bash
+# Build
+make
+
+# Build and run tests
+make test
+./out/run_tests_direct
+./out/run_tests_indirect
+
+# Build with options
+make DLONG=1 USE_LAPACK=1
+
+# Clean everything
+make purge
+```
+
+## Development Workflow
+
+1. Fork the repo and create a feature branch from `master`
+2. Make your changes
+3. Run the test suite to ensure nothing is broken
+4. Submit a pull request against `master`
+
+## Code Style
+
+- C99 with `-Wall -Wwrite-strings -pedantic -Werror=incompatible-pointer-types`
+- Internal functions use the `SCS(name)` macro (expands to `_scs_name`)
+- Public API functions use the `scs_` prefix directly
+- Types: `scs_float` (double/float), `scs_int` (int/long long)
+
+## Project Layout
+
+| Directory | Contents |
+|-----------|----------|
+| `include/` | Public API and internal headers |
+| `src/` | Core solver implementation |
+| `linsys/` | Linear solver backends (pluggable) |
+| `test/` | Test suite (minunit framework) |
+| `docs/src/` | Sphinx documentation source |
+
+See `CLAUDE.md` for architecture details and guides on adding new solver
+backends or cone types.

data/vendor/scs/Makefile

@@ -30,6 +30,7 @@ endif
 
 SCS_O = src/scs.o
 SCS_INDIR_O = src/scs_indir.o
+SCS_MKL_O = src/scs_mkl.o
 
 SRC_FILES = $(wildcard src/*.c)
 INC_FILES = $(wildcard include/*.h)
@@ -68,6 +69,9 @@ $(SCS_O): src/scs.c $(INC_FILES)
 $(SCS_INDIR_O): src/scs.c $(INC_FILES)
 	$(CC) $(CFLAGS) -DINDIRECT=1 -c $< -o $@
 
+$(SCS_MKL_O): src/scs.c $(INC_FILES)
+	$(CC) $(CFLAGS) -DSCS_MKL=1 -c $< -o $@
+
 %.o : src/%.c
 	$(CC) $(CFLAGS) -c $< -o $@
 
@@ -77,14 +81,16 @@ src/exp_cone.o	: src/exp_cone.c $(INC_FILES)
 src/aa.o	: src/aa.c $(INC_FILES)
 src/rw.o	: src/rw.c $(INC_FILES)
 src/linalg.o: src/linalg.c $(INC_FILES)
-src/ctrl.o  : src/ctrl.c $(INC_FILES)
+src/ctrlc.o : src/ctrlc.c $(INC_FILES)
 src/scs_version.o: src/scs_version.c $(INC_FILES)
 
 $(DIRSRC)/private.o: $(DIRSRC)/private.c  $(DIRSRC)/private.h
-$(INDIRSRC)/indirect/private.o: $(INDIRSRC)/private.c $(INDIRSRC)/private.h
+$(INDIRSRC)/private.o: $(INDIRSRC)/private.c $(INDIRSRC)/private.h
+$(DENSESRC)/private.o: $(DENSESRC)/private.c  $(DENSESRC)/private.h
 $(MKLSRC)/private.o: $(MKLSRC)/private.c  $(MKLSRC)/private.h
 $(CUDSSSRC)/private.o: $(CUDSSSRC)/private.c  $(CUDSSSRC)/private.h
 	$(CUCC) $(INCLUDE) $(CUDSS_FLAGS) -I$(CUDSSSRC) -c $(CUDSSSRC)/private.c -o $@
+$(ACCELSRC)/private.o: $(ACCELSRC)/private.c  $(ACCELSRC)/private.h
 $(LINSYS)/scs_matrix.o: $(LINSYS)/scs_matrix.c $(LINSYS)/scs_matrix.h
 $(LINSYS)/csparse.o: $(LINSYS)/csparse.c $(LINSYS)/csparse.h
 
@@ -98,31 +104,53 @@ $(OUT)/libscsindir.a: $(SCS_INDIR_O) $(SCS_OBJECTS) $(INDIRSRC)/private.o $(LINS
 	$(ARCHIVE) $@ $^
 	- $(RANLIB) $@
 
-$(OUT)/libscsmkl.a: $(SCS_O) $(SCS_OBJECTS) $(MKLSRC)/private.o $(LINSYS)/scs_matrix.o $(LINSYS)/csparse.o
+$(OUT)/libscsdense.a: $(SCS_O) $(SCS_OBJECTS) $(DENSESRC)/private.o $(LINSYS)/scs_matrix.o $(LINSYS)/csparse.o
 	mkdir -p $(OUT)
 	$(ARCHIVE) $@ $^
 	- $(RANLIB) $@
 
-$(OUT)/libscscudss.a: $(SCS_O) $(SCS_OBJECTS) $(CUDSSSRC)/private.o $(LINSYS)/scs_matrix.o $(LINSYS)/csparse.o
+$(OUT)/libscsmkl.a: $(SCS_MKL_O) $(SCS_OBJECTS) $(MKLSRC)/private.o $(LINSYS)/scs_matrix.o $(LINSYS)/csparse.o
 	mkdir -p $(OUT)
 	$(ARCHIVE) $@ $^
 	- $(RANLIB) $@
 
-$(OUT)/libscsdir.$(SHARED): $(SCS_O) $(SCS_OBJECTS) $(DIRSRC)/private.o $(AMD_OBJS) $(LDL_OBJS) $(LINSYS)/scs_matrix.o $(LINSYS)/csparse.o
+$(OUT)/libscscudss.a: $(SCS_O) $(SCS_OBJECTS) $(CUDSSSRC)/private.o $(LINSYS)/scs_matrix.o $(LINSYS)/csparse.o
 	mkdir -p $(OUT)
-	$(CC) $(CFLAGS) -shared -Wl,$(SONAME),$(@:$(OUT)/%=%) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS)
+	$(ARCHIVE) $@ $^
+	- $(RANLIB) $@
 
-$(OUT)/libscsindir.$(SHARED): $(SCS_INDIR_O) $(SCS_OBJECTS) $(INDIRSRC)/private.o $(LINSYS)/scs_matrix.o $(LINSYS)/csparse.o
+$(OUT)/libscsaccel.a: $(SCS_O) $(SCS_OBJECTS) $(ACCELSRC)/private.o $(LINSYS)/scs_matrix.o $(LINSYS)/csparse.o
 	mkdir -p $(OUT)
-	$(CC) $(CFLAGS) -shared -Wl,$(SONAME),$(@:$(OUT)/%=%) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS)
+	$(ARCHIVE) $@ $^
+	- $(RANLIB) $@
 
-$(OUT)/libscsmkl.$(SHARED): $(SCS_O) $(SCS_OBJECTS) $(MKLSRC)/private.o $(LINSYS)/scs_matrix.o $(LINSYS)/csparse.o
+# Link a shared library as its versioned file with the ABI version as its
+# soname/install_name, then point the unversioned name at it (Windows: the
+# DLL itself, unversioned). $(1): extra link flags.
+V = $(call versioned,$@)
+define link_shared
 	mkdir -p $(OUT)
-	$(CC) $(CFLAGS) -shared -Wl,$(SONAME),$(@:$(OUT)/%=%) -o $@ $^ $(LDFLAGS) $(MKLFLAGS)
+	$(CC) $(CFLAGS) -shared -Wl,$(SONAME),$(notdir $(V)) -o $(V) $^ $(LDFLAGS) $(1)
+	[ "$(V)" = "$@" ] || ln -sf $(notdir $(V)) $@
+endef
+
+$(OUT)/libscsdir.$(SHARED): $(SCS_O) $(SCS_OBJECTS) $(DIRSRC)/private.o $(AMD_OBJS) $(LDL_OBJS) $(LINSYS)/scs_matrix.o $(LINSYS)/csparse.o
+	$(call link_shared,$(BLASLDFLAGS))
+
+$(OUT)/libscsindir.$(SHARED): $(SCS_INDIR_O) $(SCS_OBJECTS) $(INDIRSRC)/private.o $(LINSYS)/scs_matrix.o $(LINSYS)/csparse.o
+	$(call link_shared,$(BLASLDFLAGS))
+
+$(OUT)/libscsdense.$(SHARED): $(SCS_O) $(SCS_OBJECTS) $(DENSESRC)/private.o $(LINSYS)/scs_matrix.o $(LINSYS)/csparse.o
+	$(call link_shared,$(BLASLDFLAGS))
+
+$(OUT)/libscsmkl.$(SHARED): $(SCS_MKL_O) $(SCS_OBJECTS) $(MKLSRC)/private.o $(LINSYS)/scs_matrix.o $(LINSYS)/csparse.o
+	$(call link_shared,$(MKLFLAGS))
 
 $(OUT)/libscscudss.$(SHARED): $(SCS_O) $(SCS_OBJECTS) $(CUDSSSRC)/private.o $(LINSYS)/scs_matrix.o $(LINSYS)/csparse.o
-	mkdir -p $(OUT)
-	$(CC) $(CFLAGS) -shared -Wl,$(SONAME),$(@:$(OUT)/%=%) -o $@ $^ $(LDFLAGS) $(CULDFLAGS)
+	$(call link_shared,$(CULDFLAGS))
+
+$(OUT)/libscsaccel.$(SHARED): $(SCS_O) $(SCS_OBJECTS) $(ACCELSRC)/private.o $(LINSYS)/scs_matrix.o $(LINSYS)/csparse.o
+	$(call link_shared,-framework Accelerate)
 
 $(OUT)/demo_socp_direct: test/random_socp_prob.c $(OUT)/libscsdir.a
 	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS)
@@ -130,12 +158,18 @@ $(OUT)/demo_socp_direct: test/random_socp_prob.c $(OUT)/libscsdir.a
 $(OUT)/demo_socp_indirect: test/random_socp_prob.c $(OUT)/libscsindir.a
 	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS)
 
+$(OUT)/demo_socp_dense: test/random_socp_prob.c $(OUT)/libscsdense.a
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS)
+
 $(OUT)/demo_socp_mkl: test/random_socp_prob.c $(OUT)/libscsmkl.a
 	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(MKLFLAGS)
 
 $(OUT)/demo_socp_cudss: test/random_socp_prob.c $(OUT)/libscscudss.a
 	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS) $(CUDSS_LDFLAGS)
 
+$(OUT)/demo_socp_accelerate: test/random_socp_prob.c $(OUT)/libscsaccel.a
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) -framework Accelerate
+
 $(OUT)/run_from_file_direct: test/run_from_file.c $(OUT)/libscsdir.a
 	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS)
 
@@ -147,19 +181,35 @@ $(OUT)/run_from_file_gpu_indirect: test/run_from_file.c $(OUT)/libscsgpuindir.a
 
 # basic testing
 .PHONY: test
-test: $(OUT)/run_tests_indirect $(OUT)/run_tests_direct
+TEST_TARGETS = $(OUT)/run_tests_indirect $(OUT)/run_tests_direct
+ifneq ($(USE_LAPACK),0)
+TEST_TARGETS += $(OUT)/run_tests_dense
+endif
+ifeq ($(UNAME), Darwin)
+ifeq ($(DLONG), 0)
+TEST_TARGETS += $(OUT)/run_tests_accelerate
+endif
+endif
+test: $(TEST_TARGETS)
 $(OUT)/run_tests_indirect: test/run_tests.c $(OUT)/libscsindir.a
 	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS) -Itest
 $(OUT)/run_tests_direct: test/run_tests.c $(OUT)/libscsdir.a
 	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS) -Itest
+$(OUT)/test_rw_settings: test/rw_settings.c test/problems/test_rw_settings.h $(OUT)/libscsdir.a
+	$(CC) $(CFLAGS) -o $@ $< $(OUT)/libscsdir.a $(LDFLAGS) $(BLASLDFLAGS) -Itest
+$(OUT)/run_tests_dense: test/run_tests.c $(OUT)/libscsdense.a
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS) -Itest
 $(OUT)/run_tests_mkl: test/run_tests.c $(OUT)/libscsmkl.a
 	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(MKLFLAGS) -Itest
 
 $(OUT)/run_tests_cudss: test/run_tests.c $(OUT)/libscscudss.a
 	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS) $(CUDSS_LDFLAGS) -Itest
 
+$(OUT)/run_tests_accelerate: test/run_tests.c $(OUT)/libscsaccel.a
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) -framework Accelerate -Itest
+
 .PHONY: test_gpu
-test_gpu: $(OUT)/run_tests_gpu_indirect # $(OUT)/run_tests_gpu_direct
+test_gpu: $(OUT)/run_tests_gpu_indirect
 
 .PHONY: mkl
 mkl: mklroot $(OUT)/libscsmkl.a $(OUT)/libscsmkl.$(SHARED) $(OUT)/run_tests_mkl $(OUT)/demo_socp_mkl
@@ -168,57 +218,41 @@ ifndef MKLROOT
 	$(error MKLROOT is undefined, set MKLROOT to the MKL install location)
 endif
 
-.PHONY:
+.PHONY: cudss
 cudss: $(OUT)/libscscudss.a $(OUT)/libscscudss.$(SHARED) $(OUT)/run_tests_cudss $(OUT)/demo_socp_cudss
 
+.PHONY: accelerate
+accelerate: $(OUT)/libscsaccel.a $(OUT)/libscsaccel.$(SHARED) $(OUT)/run_tests_accelerate $(OUT)/demo_socp_accelerate
+
 $(OUT)/run_tests_gpu_indirect: test/run_tests.c $(OUT)/libscsgpuindir.a
 	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS) $(CULDFLAGS) -Itest
 
-# $(OUT)/run_tests_gpu_direct: test/run_tests.c $(OUT)/libscsgpudir.a
-# 	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS) $(CULDFLAGS) -Itest
-
 # REQUIRES GPU AND CUDA INSTALLED
-gpu: gpu_indirect # gpu_direct
+# Note: only the GPU indirect solver is currently implemented.
+gpu: gpu_indirect
 
-# 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
 	$(CC) -c -o $@ $^ $(CUDAFLAGS)
 
-# $(GPUDIR)/private.o: $(GPUDIR)/private.c
-# 	$(CUCC) -c -o $(GPUDIR)/private.o $^ $(CUDAFLAGS)
-
 $(GPUINDIR)/private.o: $(GPUINDIR)/private.c
 	$(CC) -c -o $@ $^ $(CUDAFLAGS)
 
-# $(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) $(BLASLDFLAGS) $(CULDFLAGS)
-
-# $(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_INDIR_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) $(BLASLDFLAGS) $(CULDFLAGS)
+	$(call link_shared,$(BLASLDFLAGS) $(CULDFLAGS))
 
 $(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) $@
 
-# $(OUT)/demo_socp_gpu_direct: test/random_socp_prob.c $(OUT)/libscsgpudir.a
-# 	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS) $(CULDFLAGS)
-
 $(OUT)/demo_socp_gpu_indirect: test/random_socp_prob.c $(OUT)/libscsgpuindir.a
 	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS) $(CULDFLAGS)
 
 .PHONY: clean purge
 clean:
-	@rm -rf $(TARGETS) $(SCS_O) $(SCS_INDIR_O) $(SCS_OBJECTS) $(AMD_OBJS) $(LDL_OBJS) $(LINSYS)/*.o $(DIRSRC)/*.o $(INDIRSRC)/*.o $(MKLSRC)/*.o $(GPUDIR)/*.o $(GPUINDIR)/*.o $(LINSYS)/gpu/*.o
+	@rm -rf $(TARGETS) $(SCS_O) $(SCS_INDIR_O) $(SCS_MKL_O) $(SCS_OBJECTS) $(AMD_OBJS) $(LDL_OBJS) $(LINSYS)/*.o $(DIRSRC)/*.o $(INDIRSRC)/*.o $(DENSESRC)/*.o $(MKLSRC)/*.o $(ACCELSRC)/*.o $(GPUDIR)/*.o $(GPUINDIR)/*.o $(LINSYS)/gpu/*.o src/spectral_cones/*.o src/spectral_cones/*/*.o
 	@rm -rf $(OUT)/*.dSYM
 	@rm -rf matlab/*.mex*
 	@rm -rf .idea
@@ -230,19 +264,32 @@ purge: clean
 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_GPU_TARGETS = $(OUT)/libscsgpuindir.a $(OUT)/libscsgpuindir.$(SHARED)
+
+# shared libraries are installed under their versioned names with the
+# unversioned symlink alongside
+INSTALL_SHARED = $(filter %.$(SHARED),$(INSTALL_TARGETS))
+INSTALL_GPU_SHARED = $(filter %.$(SHARED),$(INSTALL_GPU_TARGETS))
+# the versioned files, plus the unversioned symlinks copied as symlinks
+install_shared = $(INSTALL) -m 644 $(call versioned,$(1)) $(INSTALL_LIB_DIR) && \
+	{ [ "$(call versioned,$(1))" = "$(1)" ] || cp -RP $(1) $(INSTALL_LIB_DIR); }
 
 INSTALL_INC_DIR = $(DESTDIR)$(PREFIX)/include/scs/
 INSTALL_LIB_DIR = $(DESTDIR)$(PREFIX)/lib/
 
+.PHONY: dense
+dense: $(OUT)/libscsdense.a $(OUT)/libscsdense.$(SHARED) $(OUT)/run_tests_dense $(OUT)/demo_socp_dense
+
 .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)
-	$(INSTALL) -m 644 $(INSTALL_TARGETS) $(INSTALL_LIB_DIR)
+	$(INSTALL) -m 644 $(filter-out %.$(SHARED),$(INSTALL_TARGETS)) $(INSTALL_LIB_DIR)
+	$(call install_shared,$(INSTALL_SHARED))
 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
+	$(INSTALL) -m 644 $(filter-out %.$(SHARED),$(INSTALL_GPU_TARGETS)) $(INSTALL_LIB_DIR)
+	$(call install_shared,$(INSTALL_GPU_SHARED))
+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

@@ -4,11 +4,105 @@
 
 [![Build Status](https://github.com/cvxgrp/scs/actions/workflows/build.yml/badge.svg)](https://github.com/cvxgrp/scs/actions/workflows/build.yml)
 [![Documentation](https://img.shields.io/badge/docs-online-brightgreen?logo=read-the-docs&style=flat)](https://www.cvxgrp.org/scs/)
-
+[![PyPI Downloads](https://api.pepy.tech/personalized-badge/scs?period=month&units=international_system&left_color=grey&right_color=blue&left_text=PyPI%20downloads%2Fmonth)](https://pepy.tech/projects/scs)
+[![Conda Downloads](https://img.shields.io/conda/dn/conda-forge/scs.svg?label=Conda%20downloads)](https://anaconda.org/conda-forge/scs)
 
 SCS (`splitting conic solver`) is a numerical optimization package for solving
-large-scale convex cone problems. The current version is `3.2.11`.
+large-scale convex cone problems. The current version is `3.3.1`.
 
 The full documentation is available [here](https://www.cvxgrp.org/scs/).
 
 If you wish to cite SCS please cite the papers listed [here](https://www.cvxgrp.org/scs/citing).
+
+## Overview
+
+SCS solves convex cone programs of the form:
+
+```
+minimize    (1/2) x'Px + c'x
+subject to  Ax + s = b, s in K
+```
+
+where `K` is a product of convex cones. It uses an operator-splitting method
+(ADMM) with Anderson acceleration to achieve fast convergence.
+
+**Supported cones:** linear (LP), second-order (SOCP), semidefinite (SDP),
+exponential, power, complex semidefinite, and spectral cones (log-determinant,
+nuclear norm, sum-of-largest eigenvalues).
+
+## Features
+
+- Multiple linear solver backends: sparse direct (QDLDL), dense direct (LAPACK),
+  iterative (CG), Intel MKL Pardiso, Apple Accelerate (macOS), NVIDIA cuDSS, GPU
+- Anderson acceleration for faster convergence, including solve diagnostics
+- Problem data normalization/equilibration for numerical stability
+- Warm-starting and incremental `b`/`c` updates via `scs_update`
+- Ctrl-C signal handling for graceful interruption
+- Configurable precision (`float`/`double`) and index type (`int`/`long long`)
+- MIT licensed
+
+## Building from Source
+
+### Make (default)
+
+```bash
+make                    # Build direct + indirect solvers with BLAS/LAPACK
+make test               # Build test binaries
+./out/run_tests_direct  # Run direct solver tests
+./out/run_tests_indirect
+```
+
+### CMake
+
+```bash
+mkdir build && cd build
+cmake -DBUILD_TESTING=ON -DUSE_LAPACK=ON ..
+cmake --build .
+ctest
+```
+
+### Common Build Flags
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `USE_LAPACK` | `1` | Enable BLAS/LAPACK (required for SDP support) |
+| `DLONG` | `0` | Use 64-bit integer indexing |
+| `SFLOAT` | `0` | Use single-precision floats |
+| `USE_SPECTRAL_CONES` | `0` | Enable spectral cone support (requires LAPACK) |
+| `USE_OPENMP` | `0` | Enable OpenMP parallelization |
+
+Example: `make DLONG=1 USE_LAPACK=1`
+
+## Language Interfaces
+
+SCS has interfaces for several languages:
+
+- **Python:** `pip install scs` ([PyPI](https://pypi.org/project/scs/))
+- **Julia:** [SCS.jl](https://github.com/jump-dev/SCS.jl)
+- **R:** [scs](https://cran.r-project.org/package=scs)
+- **MATLAB:** See the [documentation](https://www.cvxgrp.org/scs/install/matlab.html)
+- **Ruby:** [scs-ruby](https://github.com/ankane/scs-ruby)
+
+SCS is the default solver in [CVXPY](https://www.cvxpy.org/).
+
+## Project Structure
+
+```
+include/        Public API and internal headers
+src/            Core solver implementation
+linsys/         Linear solver backends (pluggable architecture)
+  cpu/direct/     Sparse Cholesky (QDLDL, default)
+  cpu/indirect/   Conjugate gradient
+  cpu/dense/      Dense LU (LAPACK dgetrf, for small problems)
+  mkl/direct/     Intel MKL Pardiso
+  accelerate/direct/  Apple Accelerate sparse LDLt (macOS)
+  cudss/direct/   NVIDIA cuDSS
+  gpu/indirect/   GPU iterative solver
+  external/       Vendored dependencies (AMD, QDLDL)
+test/           Test suite (minunit framework)
+docs/src/       Sphinx documentation source
+```
+
+## License
+
+MIT License. See [LICENSE.txt](LICENSE.txt).

data/vendor/scs/include/aa.h

@@ -1,3 +1,9 @@
+/*
+ * Anderson acceleration (AA) interface for fixed-point iteration.
+ * Stores a sliding window of past iterates and computes an accelerated
+ * step that can dramatically speed up convergence of ADMM.
+ */
+
 #ifndef AA_H_GUARD
 #define AA_H_GUARD
 
@@ -5,36 +11,63 @@
 extern "C" {
 #endif
 
+#include "aa_stats.h"
 #include "glbopts.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
 
 typedef scs_float aa_float;
 typedef scs_int aa_int;
 
-typedef struct ACCEL_WORK AaWork;
+/* AaWork is declared in scs.h (included via glbopts.h) */
 
 /**
  * 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 min_len           minimum number of past iterates required before AA
+ *                          begins producing updates. Must be >= 1 when
+ *                          mem > 0; if min_len exceeds the effective
+ *                          memory (min(mem, dim)) it is clamped down,
+ *                          mirroring how `mem` is clamped to `dim` for
+ *                          rank stability. Set min_len == mem to delay
+ *                          AA until the memory is full (stable default
+ *                          for large `mem`); set min_len == 1 to start
+ *                          extrapolating from the very first residual
+ *                          pair (useful when `mem` is large but you
+ *                          still want early acceleration). Ignored when
+ *                          mem == 0.
  * @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 regularization    Tikhonov regularization for the AA least-squares
+ *                          system. Three modes, selected by sign:
+ *                            > 0 : problem-scaled, r = regularization *
+ *                                  ||A||_F ||Y||_F. Type-I: 1e-8 works well;
+ *                                  Type-II: more stable, 1e-12 often fine.
+ *                            < 0 : pinned absolute, r = -regularization
+ *                                  (no Frobenius scaling — useful when the
+ *                                  problem scale is known).
+ *                            = 0 : no regularization.
+ *                          Only non-finite values (NaN/Inf) are rejected.
+ * @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 ir_max_steps      max iterative refinement passes on the γ solve.
+ *                          0 disables IR. Each step is O(mem²) and loops
+ *                          until the correction stops contracting, so on
+ *                          well-conditioned problems only one step runs
+ *                          regardless of this cap. Raise it (e.g. 5) for
+ *                          ill-conditioned systems where more digits can
+ *                          be recovered; lower it for tighter cost bounds.
  * @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);
+AaWork *aa_init(aa_int dim, aa_int mem, aa_int min_len, aa_int type1,
+                aa_float regularization, aa_float relaxation,
+                aa_float safeguard_factor, aa_float max_weight_norm,
+                aa_int ir_max_steps, aa_int verbosity);
+
 /**
  * Apply Anderson Acceleration. The usage pattern should be as follows:
  *
@@ -42,7 +75,7 @@ AaWork *aa_init(aa_int dim, aa_int mem, aa_int type1, aa_float regularization,
  *    -  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
+ *    -  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.
@@ -88,12 +121,27 @@ void aa_finish(AaWork *a);
  * Reset Anderson Acceleration.
  *
  * Resets AA as if at the first iteration, reuses original memory allocations.
+ * Does not clear lifetime diagnostic counters; use aa_get_stats after reset
+ * to read them, or just re-init the workspace for a clean slate.
  *
  * @param a   AA workspace from aa_init
  *
  */
 void aa_reset(AaWork *a);
 
+/**
+ * Return lifetime diagnostic counters.
+ *
+ * Use for post-hoc diagnosis of why AA is or isn't accelerating a
+ * given fixed-point iteration — e.g. `n_reject_weight_cap` rising
+ * suggests loosening `max_weight_norm` or raising `regularization`;
+ * `n_safeguard_reject` rising suggests tuning `safeguard_factor` or
+ * `mem`. Do not call with `a == NULL`.
+ *
+ * @param a    AA workspace from aa_init (must be non-NULL).
+ */
+AaStats aa_get_stats(const AaWork *a);
+
 #ifdef __cplusplus
 }
 #endif

data/vendor/scs/include/aa_stats.h

@@ -0,0 +1,47 @@
+/*
+ * Public Anderson acceleration diagnostic counters.
+ */
+
+#ifndef AA_STATS_H_GUARD
+#define AA_STATS_H_GUARD
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "scs_types.h"
+
+/**
+ * Lifetime diagnostics for an Anderson acceleration workspace.
+ *
+ * Counters accumulate from aa_init and are not cleared by aa_reset, including
+ * internal resets after safeguard rejections. Rejection causes are split so a
+ * caller can tell what needs tuning.
+ */
+typedef struct {
+  /** Internal AA iteration counter. */
+  scs_int iter;
+  /** Number of AA updates accepted by aa_apply before safeguarding. */
+  scs_int n_accept;
+  /** Number of AA rejections due to LAPACK errors. */
+  scs_int n_reject_lapack;
+  /** Number of AA rejections due to rank-zero reduced systems. */
+  scs_int n_reject_rank0;
+  /** Number of AA rejections due to non-finite weights. */
+  scs_int n_reject_nonfinite;
+  /** Number of AA rejections due to the weight-norm cap. */
+  scs_int n_reject_weight_cap;
+  /** Number of AA steps rejected by safeguarding. */
+  scs_int n_safeguard_reject;
+  /** Rank of the most recent AA solve. */
+  scs_int last_rank;
+  /** Weight norm from the most recent AA solve. NaN if no solve was attempted. */
+  scs_float last_aa_norm;
+  /** Regularization used in the most recent AA solve. */
+  scs_float last_regularization;
+} AaStats;
+
+#ifdef __cplusplus
+}
+#endif
+#endif

data/vendor/scs/include/cones.h

@@ -6,15 +6,13 @@ extern "C" {
 #endif
 
 #include "glbopts.h"
-#include "scs.h"
 #include "scs_blas.h"
 #include "scs_work.h"
-#include <string.h>
 
 #ifdef USE_SPECTRAL_CONES
-#include "util_spectral_cones.h" // for newton_stats
+#include "util_spectral_cones.h" /* for Newton_stats */
 
-// macro for time measurements of SpectralSCS
+/* macro for time measurements of SpectralSCS */
 #ifdef SPECTRAL_TIMING_FLAG
 #define SPECTRAL_TIMING(action) action
 #else
@@ -32,11 +30,21 @@ struct SCS_CONE_WORK {
   ScsCone *k; /* original cone information */
   scs_int *cone_boundaries;
   scs_int cone_boundaries_len;
+  /* Per boundary entry: matrix dimension n if the block is a real PSD
+   * cone (svec length n(n+1)/2), else 0. PSD blocks admit a richer
+   * cone-invariant metric than a single scalar: any svec-diagonal
+   * weight of the rank-one form w_ij = delta_i * delta_j (a diagonal
+   * congruence X -> DXD). enforce_cone_boundaries fits this form for
+   * PSD blocks instead of collapsing them to one value. */
+  scs_int *cone_boundaries_psd_n;
+  /* scratch for PSD diagonal-congruence factors, length max PSD dim */
+  scs_float *psd_gamma;
   scs_int scaled_cones; /* boolean, whether the cones have been scaled */
   scs_float *s;         /* used for Moreau decomposition in projection */
   scs_int m;            /* total length of cone */
   /* box cone quantities */
   scs_float box_t_warm_start;
+  scs_float *r_box_inv; /* precomputed 1/r_box[j] for box cone Newton */
 
 #ifdef USE_LAPACK
   /* workspace for eigenvector decompositions: */
@@ -54,7 +62,7 @@ struct SCS_CONE_WORK {
   Value_index *work_ell1;
   scs_float *work_ell1_proj;
 
-  // used for timing spectral vector cone and spectral matrix cone projections
+  /* used for timing spectral vector cone and spectral matrix cone projections */
   SPECTRAL_TIMING(scs_float tot_time_mat_cone_proj;)
   SPECTRAL_TIMING(scs_float tot_time_vec_cone_proj;)
 
@@ -79,7 +87,7 @@ struct SCS_CONE_WORK {
 };
 
 void SCS(free_cone)(ScsCone *k);
-void SCS(deep_copy_cone)(ScsCone *dest, const ScsCone *src);
+scs_int SCS(deep_copy_cone)(ScsCone *dest, const ScsCone *src);
 ScsConeWork *SCS(init_cone)(ScsCone *k, scs_int m);
 char *SCS(get_cone_header)(const ScsCone *k);
 scs_int SCS(validate_cones)(const ScsData *d, const ScsCone *k);
@@ -88,7 +96,8 @@ scs_int SCS(proj_dual_cone)(scs_float *x, ScsConeWork *c,
 void SCS(finish_cone)(ScsConeWork *c);
 void SCS(set_r_y)(const ScsConeWork *c, scs_float scale, scs_float *r_y);
 void SCS(enforce_cone_boundaries)(const ScsConeWork *c, scs_float *vec,
-                                  scs_float (*f)(const scs_float *, scs_int));
+                                  scs_float (*f)(const scs_float *, scs_int),
+                                  scs_int psd_rank1);
 
 #ifdef __cplusplus
 }