scs 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e9285e6e364ac8096c960ae6a00f5b62c6c4790bbd8ca067af9ca35c3652385
-  data.tar.gz: 457069e09fe911cb688fcdd8c251dfc3282de4700aa04aadf8d1873528c8efea
+  metadata.gz: db74c6ffd6696e799a18d2f5d02f5b753020a2535e539cdd26abac388f1ea046
+  data.tar.gz: f7d5b3b98b58d812fb923193303b7f0bfcf7cb2972de2ae34a392fb9f4a5bd40
 SHA512:
-  metadata.gz: af56c89f3a6cd61f89967da3521e79fab543b66bd57d66df42800b3bbcd600ed8acd8d3390e31d4dbc94d15e55d31743685622388029fa9be6906c6a041945c8
-  data.tar.gz: e888d39ba02de61ae2fb4f166502de4442743608bea769d8fd01b9f08537ddb3ca6ac2790a49a73ed3900a983419c899ea28cf7a35a544b610a46ac68408fd38
+  metadata.gz: cf7a4948ba7a21865142a421da3e683904951faf7e602d429722cf05bdbae559dcc15484e6cb4afa6bf683ecf681757370bfa3fa7b01dab6620b300462eea703
+  data.tar.gz: 493da1d4fbe2fdb7180fffad3599137500d437b082d788365bf828dd8845469b3bf0d63863ea467c013cc2f874c5b04ab935c7129d45b1c890278dda7ad21039

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.3.2 (2022-01-17)
+
+- Updated SCS to 3.1.1
+
 ## 0.3.1 (2021-10-08)
 
 - Fixed installation on Linux

data/README.md

@@ -1,17 +1,17 @@
-# SCS
+# SCS Ruby
 
 [SCS](https://github.com/cvxgrp/scs) - the splitting conic solver - for Ruby
 
 :fire: Supports many different [problem types](https://www.cvxpy.org/tutorial/advanced/index.html#choosing-a-solver)
 
-[![Build Status](https://github.com/ankane/scs/workflows/build/badge.svg?branch=master)](https://github.com/ankane/scs/actions)
+[![Build Status](https://github.com/ankane/scs-ruby/workflows/build/badge.svg?branch=master)](https://github.com/ankane/scs-ruby/actions)
 
 ## Installation
 
 Add this line to your application’s Gemfile:
 
 ```ruby
-gem 'scs'
+gem "scs"
 ```
 
 If installation fails, you may need to install [dependencies](#dependencies).
@@ -81,22 +81,22 @@ On Heroku, use the [heroku-apt-buildpack](https://github.com/heroku/heroku-build
 
 ## History
 
-View the [changelog](https://github.com/ankane/scs/blob/master/CHANGELOG.md)
+View the [changelog](https://github.com/ankane/scs-ruby/blob/master/CHANGELOG.md)
 
 ## Contributing
 
 Everyone is encouraged to help improve this project. Here are a few ways you can help:
 
-- [Report bugs](https://github.com/ankane/scs/issues)
-- Fix bugs and [submit pull requests](https://github.com/ankane/scs/pulls)
+- [Report bugs](https://github.com/ankane/scs-ruby/issues)
+- Fix bugs and [submit pull requests](https://github.com/ankane/scs-ruby/pulls)
 - Write, clarify, or fix documentation
 - Suggest or add new features
 
 To get started with development:
 
 ```sh
-git clone --recursive https://github.com/ankane/scs.git
-cd scs
+git clone --recursive https://github.com/ankane/scs-ruby.git
+cd scs-ruby
 bundle install
 bundle exec rake compile
 bundle exec rake test

data/lib/scs/ffi.rb

@@ -27,13 +27,6 @@ module SCS
 
         dlload File.expand_path("../../vendor/scs/out/#{lib_name}.#{ext}", __dir__)
 
-        extern "size_t scs_sizeof_int(void)"
-        extern "size_t scs_sizeof_float(void)"
-
-        # TODO support other sizes
-        raise Error, "Unsupported int size" if scs_sizeof_int != 4
-        raise Error, "Unsupported float size" if scs_sizeof_float != 8
-
         typealias "scs_float", "double"
         typealias "scs_int", "int"
 
@@ -71,6 +64,7 @@ module SCS
         m::Info = struct [
           "scs_int iter",
           "char status[128]",
+          "char lin_sys_solver[128]",
           "scs_int status_val",
           "scs_int scale_updates",
           "scs_float pobj",

data/lib/scs/version.rb

@@ -1,3 +1,3 @@
 module SCS
-  VERSION = "0.3.1"
+  VERSION = "0.3.2"
 end

data/vendor/scs/CITATION.cff

@@ -10,7 +10,7 @@ authors:
 - family-names: "Boyd"
   given-names: "Stephen"
 title: "SCS: Spltting Conic Solver"
-version: 3.0.0
+version: 3.1.1
 date-released: 2021
 url: "https://github.com/cvxgrp/scs"
 

data/vendor/scs/CMakeLists.txt

@@ -5,7 +5,7 @@ cmake_minimum_required(VERSION 3.5)
 
 project(scs
   LANGUAGES C
-  VERSION 2.1.4)
+  VERSION 3.1.1)
 
 # Defines the CMAKE_INSTALL_LIBDIR, CMAKE_INSTALL_BINDIR and many other useful macros.
 # See https://cmake.org/cmake/help/latest/module/GNUInstallDirs.html
@@ -88,6 +88,10 @@ if(BUILD_TESTING)
   enable_testing()
 endif()
 
+# Add uninstall target
+# After 'make install' can run 'make uninstall' to remove.
+include(AddUninstallTarget)
+
 ### Some variables useful for sampling the building process
 # Note that the GPU profile is not compiled.
 set(LINSYS linsys)
@@ -95,6 +99,46 @@ set(DIRSRC ${LINSYS}/cpu/direct)
 set(INDIRSRC ${LINSYS}/cpu/indirect)
 set(EXTERNAL ${LINSYS}/external)
 
+# Options
+# ----------------------------------------------
+# Use floats instead of doubles
+option(SFLOAT "Use single precision floats rather than doubles" OFF)
+message(STATUS "Single precision floats (32bit) are ${SFLOAT}")
+
+# Use long integers for indexing
+option(DLONG "Use long integers (64bit) for indexing" OFF)
+message(STATUS "Long integers (64bit) are ${DLONG}")
+
+
+set(COMPILER_OPTS "-DUSE_LAPACK -DCOPYAMATRIX -DCTRLC")
+
+# Primitive types
+if(SFLOAT)
+  set(SCS_FLOAT_TYPE "float")
+  set(COMPILER_OPTS "-DSFLOAT ${COMPILER_OPTS}")
+else()
+  set(SCS_FLOAT_TYPE "double")
+endif()
+
+if(DLONG)
+  set(SCS_INT_TYPE "long long")
+  set(COMPILER_OPTS "-DDLONG ${COMPILER_OPTS}")
+else()
+  set(SCS_INT_TYPE "int")
+endif()
+
+message(STATUS "COMPILER_OPTS = ${COMPILER_OPTS}")
+
+# TODO this is a hack that overwrites the scs_types.h file, we should
+# find a way to do this that doesn't pollute the master directory.
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/scs_types.h.in
+               ${CMAKE_CURRENT_SOURCE_DIR}/include/scs_types.h
+               NEWLINE_STYLE LF)
+
+# Public headers 
+set(${PROJECT_NAME}_PUBLIC_HDR
+  include/scs_types.h
+  include/scs.h)
 
 # Common source files
 set(${PROJECT_NAME}_SRC
@@ -122,6 +166,8 @@ set(${PROJECT_NAME}_HDR
   include/rw.h
   include/scs.h
   include/scs_blas.h
+  include/scs_types.h
+  include/scs_work.h
   include/util.h
   ${LINSYS}/csparse.h
   ${LINSYS}/scs_matrix.h)
@@ -162,7 +208,7 @@ target_include_directories(${${PROJECT_NAME}_DIRECT} PUBLIC
   "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/scs>")
 
 # Compiled with blas and lapack, can solve LPs, SOCPs, SDPs, ECPs, and PCPs
-target_compile_definitions(${${PROJECT_NAME}_DIRECT} PRIVATE -DUSE_LAPACK -DCOPYAMATRIX -DCTRLC)
+target_compile_definitions(${${PROJECT_NAME}_DIRECT} PRIVATE ${COMPILER_OPTS})
 
 # The library depends on math (m) blas and lapack
 target_link_libraries(${${PROJECT_NAME}_DIRECT} PRIVATE
@@ -173,7 +219,7 @@ target_link_libraries(${${PROJECT_NAME}_DIRECT} PRIVATE
 # Set some properties
 set_target_properties(${${PROJECT_NAME}_DIRECT} PROPERTIES
   VERSION ${scs_VERSION}
-  PUBLIC_HEADER "${${PROJECT_NAME}_HDR}")
+  PUBLIC_HEADER "${${PROJECT_NAME}_PUBLIC_HDR}")
 
 add_library(scs::${${PROJECT_NAME}_DIRECT} ALIAS ${${PROJECT_NAME}_DIRECT})
 
@@ -209,7 +255,7 @@ target_include_directories(${${PROJECT_NAME}_INDIRECT} PUBLIC
   "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/scs>")
 
 # Compiled with blas and lapack, can solve LPs, SOCPs, SDPs, ECPs, and PCPs
-target_compile_definitions(${${PROJECT_NAME}_INDIRECT} PRIVATE -DUSE_LAPACK -DCOPYAMATRIX -DCTRLC -DINDIRECT)
+target_compile_definitions(${${PROJECT_NAME}_INDIRECT} PRIVATE ${COMPILER_OPTS} -DINDIRECT)
 
 # The library depends on math (m) blas and lapack
 target_link_libraries(${${PROJECT_NAME}_INDIRECT} PUBLIC
@@ -220,7 +266,7 @@ target_link_libraries(${${PROJECT_NAME}_INDIRECT} PUBLIC
 # Set some properties
 set_target_properties(${${PROJECT_NAME}_INDIRECT} PROPERTIES
   VERSION ${scs_VERSION}
-  PUBLIC_HEADER "${${${PROJECT_NAME}_INDIRECT}_HDR}")
+  PUBLIC_HEADER "${${PROJECT_NAME}_PUBLIC_HDR}")
 
 add_library(scs::${${PROJECT_NAME}_INDIRECT} ALIAS ${${PROJECT_NAME}_INDIRECT})
 
@@ -250,20 +296,22 @@ install_basic_package_files(${PROJECT_NAME}
 ### Add the tests
 if(BUILD_TESTING)
   add_executable(run_tests_direct  test/run_tests.c)
+  target_compile_definitions(run_tests_direct PRIVATE ${COMPILER_OPTS})
   target_link_libraries(run_tests_direct PRIVATE
     scs::scsdir)
   target_include_directories(run_tests_direct PRIVATE
-    "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/test;${CMAKE_CURRENT_SOURCE_DIR}/include;${CMAKE_CURRENT_SOURCE_DIR}/${LINSYS}>")
+    "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/test;${CMAKE_CURRENT_SOURCE_DIR}/include;${CMAKE_CURRENT_SOURCE_DIR}/${LINSYS}>"  )
 
   add_test(NAME run_tests_direct
     COMMAND run_tests_direct
     WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
 
   add_executable(run_tests_indirect  test/run_tests.c)
+  target_compile_definitions(run_tests_indirect PRIVATE ${COMPILER_OPTS})
   target_link_libraries(run_tests_indirect PRIVATE
     scs::scsindir)
   target_include_directories(run_tests_indirect PRIVATE
-    "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/test;${CMAKE_CURRENT_SOURCE_DIR}/include;${CMAKE_CURRENT_SOURCE_DIR}/${LINSYS}>")
+    "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/test;${CMAKE_CURRENT_SOURCE_DIR}/include;${CMAKE_CURRENT_SOURCE_DIR}/${LINSYS}>"  )
 
   add_test(NAME run_tests_indirect
     COMMAND run_tests_indirect

data/vendor/scs/Makefile

@@ -39,13 +39,13 @@ $(SCS_INDIR_O): src/scs.c $(INC_FILES)
 %.o : src/%.c
 	$(CC) $(CFLAGS) -c $< -o $@
 
-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/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
+src/util.o	: src/util.c $(INC_FILES)
+src/cones.o	: src/cones.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/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
@@ -115,7 +115,7 @@ $(LINSYS)/gpu/gpu.o: $(LINSYS)/gpu/gpu.c
 # 	$(CUCC) -c -o $(GPUDIR)/private.o $^ $(CUDAFLAGS)
 
 $(GPUINDIR)/private.o: $(GPUINDIR)/private.c
-	$(CUCC) -c -o $(GPUINDIR)/private.o $^ $(CUDAFLAGS)
+	$(CUCC) -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)
@@ -143,7 +143,7 @@ $(OUT)/demo_socp_gpu_indirect: test/random_socp_prob.c $(OUT)/libscsgpuindir.a
 
 .PHONY: clean purge
 clean:
-	@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 $(TARGETS) $(SCS_O) $(SCS_INDIR_O) $(SCS_OBJECTS) $(AMD_OBJS) $(LDL_OBJS) $(LINSYS)/*.o $(DIRSRC)/*.o $(INDIRSRC)/*.o $(GPUDIR)/*.o $(GPUINDIR)/*.o $(LINSYS)/gpu/*.o
 	@rm -rf $(OUT)/*.dSYM
 	@rm -rf matlab/*.mex*
 	@rm -rf .idea

data/vendor/scs/README.md

@@ -3,10 +3,11 @@
 </h1>
 
 [![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/)
 [![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. The current version is `3.0.0`.
+large-scale convex cone problems. The current version is `3.1.1`.
 
 The full documentation is available [here](https://www.cvxgrp.org/scs/).

data/vendor/scs/include/aa.h

@@ -23,7 +23,7 @@ typedef struct ACCEL_WORK AaWork;
  * @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 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

data/vendor/scs/include/cones.h

@@ -8,6 +8,8 @@ extern "C" {
 #include "glbopts.h"
 #include "scs.h"
 #include "scs_blas.h"
+#include "scs_work.h"
+#include <string.h>
 
 /* private data to help cone projection step */
 struct SCS_CONE_WORK {
@@ -16,8 +18,12 @@ struct SCS_CONE_WORK {
    * 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;
+  const ScsCone *k; /* original cone information */
+  scs_int *cone_boundaries;
+  scs_int cone_boundaries_len;
+  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 *bl, *bu, box_t_warm_start;
 #ifdef USE_LAPACK
@@ -27,18 +33,15 @@ struct SCS_CONE_WORK {
 #endif
 };
 
-ScsConeWork *SCS(init_cone)(const ScsCone *k, const ScsScaling *scal,
-                            scs_int cone_len);
+ScsConeWork *SCS(init_cone)(const ScsCone *k, scs_int m);
 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);
-
-scs_int SCS(proj_dual_cone)(scs_float *x, const ScsCone *k, ScsConeWork *c,
-                            scs_int normalize);
+scs_int SCS(proj_dual_cone)(scs_float *x, ScsConeWork *c, ScsScaling *scal,
+                            scs_float *r_y);
 void SCS(finish_cone)(ScsConeWork *c);
-
-void SCS(set_rho_y_vec)(const ScsCone *k, scs_float scale, scs_float *rho_y_vec,
-                        scs_int m);
+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));
 
 #ifdef __cplusplus
 }

data/vendor/scs/include/glbopts.h

@@ -5,27 +5,16 @@
 extern "C" {
 #endif
 
+#include "scs.h"
 #include <math.h>
 
 #ifndef SCS
-#define SCS(x) scs_##x
+#define SCS(x) _scs_##x
 #endif
 
 /* SCS VERSION NUMBER ----------------------------------------------    */
-#define SCS_VERSION                                                            \
-  ("3.0.0") /* 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)
+/* string literals automatically null-terminated */
+#define SCS_VERSION ("3.1.1")
 
 /* verbosity level */
 #ifndef VERBOSITY
@@ -54,10 +43,10 @@ extern "C" {
 #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
+#define scs_free mxFree
+#define scs_malloc mxMalloc
+#define scs_calloc mxCalloc
+#define scs_realloc mxRealloc
 #elif defined PYTHON
 #include <Python.h>
 #define scs_printf(...)                                                        \
@@ -66,18 +55,18 @@ extern "C" {
     PySys_WriteStdout(__VA_ARGS__);                                            \
     PyGILState_Release(gilstate);                                              \
   }
-/* only for SuiteSparse */
-#define _scs_printf PySys_WriteStdout
 #if PY_MAJOR_VERSION >= 3
-#define _scs_free PyMem_RawFree
-#define _scs_malloc PyMem_RawMalloc
-#define _scs_realloc PyMem_RawRealloc
-#define _scs_calloc PyMem_RawCalloc
+#define scs_free PyMem_RawFree
+#define scs_malloc PyMem_RawMalloc
+#define scs_realloc PyMem_RawRealloc
+#define scs_calloc PyMem_RawCalloc
+/* only for SuiteSparse + python */
+#define _scs_printf PySys_WriteStdout
 #else
-#define _scs_free PyMem_Free
-#define _scs_malloc PyMem_Malloc
-#define _scs_realloc PyMem_Realloc
-static inline void *_scs_calloc(size_t count, size_t size) {
+#define scs_free PyMem_Free
+#define scs_malloc PyMem_Malloc
+#define scs_realloc PyMem_Realloc
+static inline void *scs_calloc(size_t count, size_t size) {
   void *obj = PyMem_Malloc(count * size);
   memset(obj, 0, count * size);
   return obj;
@@ -88,47 +77,21 @@ static inline void *_scs_calloc(size_t count, size_t size) {
 #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
+#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;
-#else
-typedef long scs_int;
-#endif
-*/
-typedef long long scs_int;
-#else
-typedef int scs_int;
+#define scs_free free
+#define scs_malloc malloc
+#define scs_calloc calloc
+#define scs_realloc realloc
 #endif
 
 #ifndef SFLOAT
-typedef double scs_float;
 #ifndef NAN
 #define NAN ((scs_float)0x7ff8000000000000)
 #endif
@@ -136,7 +99,6 @@ typedef double scs_float;
 #define INFINITY NAN
 #endif
 #else
-typedef float scs_float;
 #ifndef NAN
 #define NAN ((float)0x7fc00000)
 #endif

data/vendor/scs/include/linalg.h

@@ -5,7 +5,7 @@
 extern "C" {
 #endif
 
-#include "scs.h"
+#include "glbopts.h"
 #include <math.h>
 
 void SCS(scale_array)(scs_float *a, const scs_float b, scs_int len);
@@ -17,6 +17,7 @@ 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);
+scs_float SCS(mean)(const scs_float *x, scs_int l);
 
 #ifdef __cplusplus
 }

data/vendor/scs/include/linsys.h

@@ -5,6 +5,7 @@
 extern "C" {
 #endif
 
+#include "glbopts.h"
 #include "scs.h"
 
 /* This is the API that any new linear system solver must implement */
@@ -16,15 +17,14 @@ extern "C" {
 /**
  * Initialize `ScsLinSysWork` structure and perform any necessary preprocessing.
  *
- *  @param  A          A data matrix.
- *  @param  P          P data matrix.
- *  @param  rho_y_vec  `rho_y > 0` diagonal entries.
- *  @param  rho_x      `rho_x > 0` float.
+ *  @param  A          `A` data matrix, `m x n`.
+ *  @param  P          `P` data matrix, `n x n`.
+ *  @param  diag_r     `R > 0` diagonal entries of length `m + n`.
  *  @return            Linear system solver workspace.
  *
  */
 ScsLinSysWork *SCS(init_lin_sys_work)(const ScsMatrix *A, const ScsMatrix *P,
-                                      scs_float *rho_y_vec, scs_float rho_x);
+                                      const scs_float *diag_r);
 
 /**
  * Frees `ScsLinSysWork` structure and associated allocated memory.
@@ -34,15 +34,15 @@ ScsLinSysWork *SCS(init_lin_sys_work)(const ScsMatrix *A, const ScsMatrix *P,
 void SCS(free_lin_sys_work)(ScsLinSysWork *w);
 
 /**
- * Solves the linear system required by SCS at each iteration:
+ * Solves the linear system as required by SCS at each iteration:
  * \f[
  *    \begin{bmatrix}
- *    (\rho_x I + P) & A^\top \\
- *     A   &  -\mathrm{diag}(\rho_y) \\
+ *    (R_x + P) & A^\top \\
+ *     A   &  -R_y \\
  *    \end{bmatrix} x = b
  *  \f]
  *
- *  for `x`. Overwrites `b` with result.
+ *  for `x`, where `diag(R_x, R_y) = R`. Overwrites `b` with result.
  *
  *  @param  w    Linear system private workspace.
  *  @param  b    Right hand side, contains solution at the end.
@@ -54,15 +54,15 @@ void SCS(free_lin_sys_work)(ScsLinSysWork *w);
 scs_int SCS(solve_lin_sys)(ScsLinSysWork *w, scs_float *b, const scs_float *s,
                            scs_float tol);
 /**
- *  Update the linsys workspace when `rho_y_vec` is changed. For example, a
+ *  Update the linsys workspace when `R` is changed. For example, a
  *  direct method for solving the linear system might need to update the
  *  factorization of the matrix.
  *
- *  @param  w          Linear system private workspace.
- *  @param  rho_y_vec  `rho_y` diagonal entries.
+ *  @param  w             Linear system private workspace.
+ *  @param  new_diag_r    Updated `diag_r`, diagonal entries of R.
  *
  */
-void SCS(update_lin_sys_rho_y_vec)(ScsLinSysWork *w, scs_float *rho_y_vec);
+void SCS(update_lin_sys_diag_r)(ScsLinSysWork *w, const scs_float *new_diag_r);
 
 /**
  * Name of the linear solver.

data/vendor/scs/include/normalize.h

@@ -5,12 +5,13 @@
 extern "C" {
 #endif
 
-#include "scs.h"
+#include "glbopts.h"
+#include "scs_work.h"
 
-void SCS(normalize_sol)(ScsWork *w, ScsSolution *sol);
-void SCS(un_normalize_sol)(ScsWork *w, ScsSolution *sol);
-void SCS(un_normalize_primal)(ScsWork *w, scs_float *r);
-void SCS(un_normalize_dual)(ScsWork *w, scs_float *r);
+void SCS(normalize_sol)(ScsScaling *scal, ScsSolution *sol);
+void SCS(un_normalize_sol)(ScsScaling *scal, ScsSolution *sol);
+void SCS(un_normalize_primal)(ScsScaling *scal, scs_float *r);
+void SCS(un_normalize_dual)(ScsScaling *scal, scs_float *r);
 
 #ifdef __cplusplus
 }