scs 0.5.1 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0383039079716cc0cd7087291d768ed2e9e5f615b78211a96e850e068c89e6bb'
-  data.tar.gz: 0dc5bd791bafcf2846e66e90ba7ac88fa93665e1b024c1041123df4e4c279007
+  metadata.gz: 5f6156bd39776692e6bf684208d4401859c8b76cbff5b031866a0e269ae66893
+  data.tar.gz: f2316371287f4b2492509950591bd763a08dc142af46e71f770e1a68897a566a
 SHA512:
-  metadata.gz: 6268655afd2200a7132125d86e4bde71c36325a8741857ed38a3b6e07686a042b310771f84df57e6b1756c00cc1c8ed1bc61b2e604b71133ba98a87471d45931
-  data.tar.gz: fce49c2615c517adb0d13362a053c3dd2534a4579fc9f1bc5a219c21ac471833e61827ac8587ebb8a07001350b93eca5f820166d8a638e47d8e45bc279c83c72
+  metadata.gz: ee213ecedba119f6a551a9df9afb634f18dba8f022817baead85c77c9befd82c33690f942f6e5be0070f20a4ef3331eab289d8d3fffe5c1a801dbc66ce99efae
+  data.tar.gz: '071879f9a45ffc9c990e3510926c028f7f33ab199e13898325da87ff368eb19463b43feca04c5c296026150ae46aa86711098d15be4792f11c0bee1ac6e6993c'

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.5.2 (2025-08-13)
+
+- Updated SCS to 3.2.8
+
 ## 0.5.1 (2025-05-04)
 
 - Fixed memory management

data/lib/scs/ffi.rb

@@ -49,6 +49,8 @@ module SCS
           "scs_int qsize",
           "scs_int *s",
           "scs_int ssize",
+          "scs_int *cs",
+          "scs_int cssize",
           "scs_int ep",
           "scs_int ed",
           "scs_float *p",

data/lib/scs/version.rb

@@ -1,3 +1,3 @@
 module SCS
-  VERSION = "0.5.1"
+  VERSION = "0.5.2"
 end

data/vendor/scs/CITATION.cff

@@ -9,8 +9,8 @@ authors:
   given-names: "Neal"
 - family-names: "Boyd"
   given-names: "Stephen"
-title: "SCS: Spltting Conic Solver"
-version: 3.2.7
+title: "SCS: Splitting Conic Solver"
+version: 3.2.8
 date-released: 2023
 url: "https://github.com/cvxgrp/scs"
 

data/vendor/scs/CMakeLists.txt

@@ -6,7 +6,7 @@ cmake_minimum_required(VERSION 3.5)
 project(
   scs
   LANGUAGES C
-  VERSION 3.2.7)
+  VERSION 3.2.8)
 
 # Defines the CMAKE_INSTALL_LIBDIR, CMAKE_INSTALL_BINDIR and many other useful
 # macros. See https://cmake.org/cmake/help/latest/module/GNUInstallDirs.html
@@ -124,10 +124,20 @@ message(STATUS "Read/write functionality is NOT ${NO_READ_WRITE}")
 option(USE_LAPACK "Whether to use BLAS/LAPACK" ON)
 message(STATUS "BLAS/LAPACK usage is ${USE_LAPACK}")
 
+# spectral cones
+option(USE_SPECTRAL_CONES "Whether to use spectral cones (requires LAPACK)" OFF)
+if(USE_SPECTRAL_CONES AND NOT USE_LAPACK)
+  message(FATAL_ERROR "USE_SPECTRAL_CONES requires USE_LAPACK to be ON")
+endif()
+
 # Enable OpenMP support
 option(USE_OPENMP "Compile with OpenMP support" OFF)
 message(STATUS "OpenMP parallelization is ${USE_OPENMP}")
 
+# Enable cuDSS support
+option(USE_CUDSS "Compile with cuDSS support" OFF)
+message(STATUS "cuDSS support is ${USE_CUDSS}")
+
 set(COMPILER_OPTS "-DCTRLC")
 set(LAPACK_LINK_LIBRARIES "")
 
@@ -154,7 +164,7 @@ if(NO_READ_WRITE)
   set(COMPILER_OPTS "-DNO_READ_WRITE=1 ${COMPILER_OPTS}")
 endif()
 
-if (USE_LAPACK)
+if(USE_LAPACK)
   set(COMPILER_OPTS "-DUSE_LAPACK ${COMPILER_OPTS}")
   list(APPEND LAPACK_LINK_LIBRARIES "blas" "lapack")
 endif()
@@ -163,6 +173,19 @@ if(USE_OPENMP)
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fopenmp")
 endif()
 
+# Flags for spectral cones.
+if(USE_SPECTRAL_CONES)
+  set(COMPILER_OPTS "-DUSE_SPECTRAL_CONES ${COMPILER_OPTS}")
+endif()
+
+if(USE_SPECTRAL_TIMING_FLAG)
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DSPECTRAL_TIMING_FLAG")
+endif()
+
+if(USE_SPECTRAL_DEBUG)
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DSPECTRAL_DEBUG")
+endif()
+
 message(STATUS "COMPILER_OPTS = ${COMPILER_OPTS}")
 message(STATUS "CMAKE_C_FLAGS = ${CMAKE_C_FLAGS}")
 
@@ -189,6 +212,23 @@ set(${PROJECT_NAME}_SRC
     ${LINSYS}/csparse.c
     ${LINSYS}/scs_matrix.c)
 
+# Spectral source files
+set(SPECTRAL_SRC
+    src/spectral_cones/logdeterminant/log_cone_Newton.c
+    src/spectral_cones/logdeterminant/log_cone_IPM.c
+    src/spectral_cones/logdeterminant/log_cone_wrapper.c
+    src/spectral_cones/logdeterminant/logdet_cone.c
+    src/spectral_cones/nuclear/ell1_cone.c
+    src/spectral_cones/nuclear/nuclear_cone.c
+    src/spectral_cones/sum-largest/sum_largest_cone.c
+    src/spectral_cones/sum-largest/sum_largest_eval_cone.c
+    src/spectral_cones/util_spectral_cones.c)
+
+# Conditionally add spectral files
+if(USE_SPECTRAL_CONES)
+  list(APPEND ${PROJECT_NAME}_SRC ${SPECTRAL_SRC})
+endif()
+
 # Common header files
 set(${PROJECT_NAME}_HDR
     include/aa.h
@@ -207,6 +247,13 @@ set(${PROJECT_NAME}_HDR
     ${LINSYS}/csparse.h
     ${LINSYS}/scs_matrix.h)
 
+# Spectral header files
+set(SPECTRAL_HDR include/util_spectral_cones.h)
+
+if(USE_SPECTRAL_CONES)
+  list(APPEND ${PROJECT_NAME}_HDR ${SPECTRAL_HDR})
+endif()
+
 # get all the c file in amd/external
 file(GLOB ${PROJECT_NAME}_AMD_EXTERNAL_SRC ${EXTERNAL}/amd/*.c)
 
@@ -245,7 +292,8 @@ target_include_directories(
 target_compile_definitions(${${PROJECT_NAME}_DIRECT} PRIVATE ${COMPILER_OPTS})
 
 # The library depends on math (m) and (optionally) blas and lapack
-target_link_libraries(${${PROJECT_NAME}_DIRECT} PRIVATE m ${LAPACK_LINK_LIBRARIES})
+target_link_libraries(${${PROJECT_NAME}_DIRECT}
+                      PRIVATE m ${LAPACK_LINK_LIBRARIES})
 
 # Set some properties
 set_target_properties(
@@ -293,7 +341,8 @@ target_compile_definitions(${${PROJECT_NAME}_INDIRECT} PRIVATE ${COMPILER_OPTS}
                                                                -DINDIRECT)
 
 # The library depends on math (m) and (optionally) blas and lapack
-target_link_libraries(${${PROJECT_NAME}_INDIRECT} PUBLIC m ${LAPACK_LINK_LIBRARIES})
+target_link_libraries(${${PROJECT_NAME}_INDIRECT}
+                      PUBLIC m ${LAPACK_LINK_LIBRARIES})
 
 # Set some properties
 set_target_properties(
@@ -347,8 +396,8 @@ if(DEFINED ENV{MKLROOT})
   target_compile_definitions(${${PROJECT_NAME}_MKL} PRIVATE ${COMPILER_OPTS})
   # See:
   # https://www.intel.com/content/www/us/en/developer/tools/oneapi/onemkl-link-line-advisor.html
-  # This is probably not correct for other systems. TODO: make SCS-MKL
-  # work for all combinations of platform / compiler / threading options.
+  # This is probably not correct for other systems. TODO: make SCS-MKL work for
+  # all combinations of platform / compiler / threading options.
   target_link_options(${${PROJECT_NAME}_MKL} PRIVATE "LINKER:--no-as-needed")
   target_link_directories(${${PROJECT_NAME}_MKL} PRIVATE $ENV{MKLROOT}/lib)
   target_link_libraries(
@@ -389,6 +438,71 @@ endif()
 
 # ##############################################################################
 
+# If cuDSS is enabled and environment variables are set, install the cuDSS
+# version
+if(USE_CUDSS)
+  find_package(CUDAToolkit REQUIRED)
+  find_package(cudss REQUIRED)
+
+  # Force 32-bit integers for cuDSS compatibility
+  if(DLONG)
+    message(
+      FATAL_ERROR
+        "cuDSS requires 32-bit integers. Set DLONG=OFF or do not use -DDLONG=ON"
+    )
+  endif()
+
+  message(STATUS "Will install SCS-cuDSS (libscscudss).")
+
+  set(CUDSSSRC ${LINSYS}/cudss/direct)
+
+  # Here we compile the direct cuDSS library
+  set(${PROJECT_NAME}_CUDSS ${PROJECT_NAME}cudss)
+  add_library(
+    ${${PROJECT_NAME}_CUDSS} ${${PROJECT_NAME}_HDR} ${${PROJECT_NAME}_SRC}
+                             ${CUDSSSRC}/private.c ${CUDSSSRC}/private.h)
+
+  target_include_directories(
+    ${${PROJECT_NAME}_CUDSS}
+    PRIVATE
+      "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/${CUDSSSRC};${CMAKE_CURRENT_SOURCE_DIR}/${LINSYS}>"
+  )
+
+  target_include_directories(
+    ${${PROJECT_NAME}_CUDSS}
+    PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
+           "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/scs>")
+
+  target_compile_definitions(${${PROJECT_NAME}_CUDSS} PRIVATE ${COMPILER_OPTS})
+
+  target_link_libraries(
+    ${${PROJECT_NAME}_CUDSS}
+    PRIVATE CUDA::cudart cudss $<$<NOT:$<PLATFORM_ID:Windows>>:m>
+            ${LAPACK_LINK_LIBRARIES})
+
+  # Set some properties
+  set_target_properties(
+    ${${PROJECT_NAME}_CUDSS}
+    PROPERTIES VERSION ${scs_VERSION} PUBLIC_HEADER
+                                      "${${PROJECT_NAME}_PUBLIC_HDR}")
+
+  add_library(scs::${${PROJECT_NAME}_CUDSS} ALIAS ${${PROJECT_NAME}_CUDSS})
+
+  # Install the library
+  install(
+    TARGETS ${${PROJECT_NAME}_CUDSS}
+    EXPORT ${PROJECT_NAME}
+    COMPONENT runtime
+    LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}" COMPONENT shlib
+    ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}" COMPONENT lib
+    RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}" COMPONENT bin
+    PUBLIC_HEADER DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/scs")
+
+  # Add the cuDSS method to the set of the compiled targets
+  set_property(GLOBAL APPEND PROPERTY SCS_TARGETS ${${PROJECT_NAME}_CUDSS})
+endif()
+
+# ##############################################################################
 # Install the .cmake file. It is possible to link scs o consumer libraries.
 include(InstallBasicPackageFiles)
 install_basic_package_files(
@@ -451,4 +565,20 @@ if(BUILD_TESTING)
       WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
   endif()
 
+  if(USE_CUDSS)
+    add_executable(run_tests_cudss test/run_tests.c)
+    target_compile_definitions(run_tests_cudss PRIVATE ${COMPILER_OPTS})
+    target_link_libraries(run_tests_cudss PRIVATE scs::scscudss)
+    target_include_directories(
+      run_tests_cudss
+      PRIVATE
+        "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/test;${CMAKE_CURRENT_SOURCE_DIR}/include;${CMAKE_CURRENT_SOURCE_DIR}/${LINSYS}>"
+    )
+
+    add_test(
+      NAME run_tests_cudss
+      COMMAND run_tests_cudss
+      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+  endif()
+
 endif()

data/vendor/scs/Makefile

@@ -1,7 +1,33 @@
 # MAKEFILE for scs
 include scs.mk
 
-SCS_OBJECTS = src/util.o src/cones.o src/exp_cone.o src/aa.o src/rw.o src/linalg.o src/ctrlc.o src/scs_version.o src/normalize.o
+# Base object files always included
+BASE_SCS_OBJECTS = \
+    src/util.o src/cones.o src/exp_cone.o src/aa.o src/rw.o src/linalg.o src/ctrlc.o src/scs_version.o src/normalize.o
+
+# Spectral cones files, only included if USE_SPECTRAL_CONES=1
+SPECTRAL_CONES_OBJECTS = \
+    src/spectral_cones/logdeterminant/log_cone_Newton.o \
+    src/spectral_cones/logdeterminant/log_cone_IPM.o \
+    src/spectral_cones/logdeterminant/log_cone_wrapper.o \
+    src/spectral_cones/logdeterminant/logdet_cone.o \
+    src/spectral_cones/nuclear/ell1_cone.o \
+    src/spectral_cones/nuclear/nuclear_cone.o \
+    src/spectral_cones/sum-largest/sum_largest_cone.o \
+    src/spectral_cones/sum-largest/sum_largest_eval_cone.o \
+    src/spectral_cones/util_spectral_cones.o
+
+# Now decide which objects to include:
+ifneq ($(USE_LAPACK),0)
+  ifneq ($(USE_SPECTRAL_CONES),0)
+    SCS_OBJECTS = $(BASE_SCS_OBJECTS) $(SPECTRAL_CONES_OBJECTS)
+  else
+    SCS_OBJECTS = $(BASE_SCS_OBJECTS)
+  endif
+else
+  SCS_OBJECTS = $(BASE_SCS_OBJECTS)
+endif
+
 SCS_O = src/scs.o
 SCS_INDIR_O = src/scs_indir.o
 
@@ -27,6 +53,12 @@ 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
+ifneq ($(USE_SPECTRAL_CONES), 0)
+	@echo "Compiled with spectral cones extension enabled (Daniel Cederberg 2025)"
+else
+	@echo "Spectral cones extension is NOT enabled. To enable spectral cones, edit"
+	@echo "scs.mk to set USE_SPECTRAL_CONES=1 and recompile."
 endif
 	@echo "****************************************************************************************"
 
@@ -51,6 +83,8 @@ 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
 $(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 $@
 $(LINSYS)/scs_matrix.o: $(LINSYS)/scs_matrix.c $(LINSYS)/scs_matrix.h
 $(LINSYS)/csparse.o: $(LINSYS)/csparse.c $(LINSYS)/csparse.h
 
@@ -69,6 +103,11 @@ $(OUT)/libscsmkl.a: $(SCS_O) $(SCS_OBJECTS) $(MKLSRC)/private.o $(LINSYS)/scs_ma
 	$(ARCHIVE) $@ $^
 	- $(RANLIB) $@
 
+$(OUT)/libscscudss.a: $(SCS_O) $(SCS_OBJECTS) $(CUDSSSRC)/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
 	mkdir -p $(OUT)
 	$(CC) $(CFLAGS) -shared -Wl,$(SONAME),$(@:$(OUT)/%=%) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS)
@@ -81,6 +120,10 @@ $(OUT)/libscsmkl.$(SHARED): $(SCS_O) $(SCS_OBJECTS) $(MKLSRC)/private.o $(LINSYS
 	mkdir -p $(OUT)
 	$(CC) $(CFLAGS) -shared -Wl,$(SONAME),$(@:$(OUT)/%=%) -o $@ $^ $(LDFLAGS) $(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)
+
 $(OUT)/demo_socp_direct: test/random_socp_prob.c $(OUT)/libscsdir.a
 	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS)
 
@@ -90,6 +133,9 @@ $(OUT)/demo_socp_indirect: test/random_socp_prob.c $(OUT)/libscsindir.a
 $(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)/run_from_file_direct: test/run_from_file.c $(OUT)/libscsdir.a
 	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS)
 
@@ -109,6 +155,8 @@ $(OUT)/run_tests_direct: test/run_tests.c $(OUT)/libscsdir.a
 $(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
 
 .PHONY: test_gpu
 test_gpu: $(OUT)/run_tests_gpu_indirect # $(OUT)/run_tests_gpu_direct
@@ -120,6 +168,8 @@ ifndef MKLROOT
 	$(error MKLROOT is undefined, set MKLROOT to the MKL install location)
 endif
 
+.PHONY:
+cudss: $(OUT)/libscscudss.a $(OUT)/libscscudss.$(SHARED) $(OUT)/run_tests_cudss $(OUT)/demo_socp_cudss
 
 $(OUT)/run_tests_gpu_indirect: test/run_tests.c $(OUT)/libscsgpuindir.a
 	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(BLASLDFLAGS) $(CULDFLAGS) -Itest
@@ -134,13 +184,13 @@ gpu: gpu_indirect # 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)
+	$(CC) -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 $@ $^ $(CUDAFLAGS)
+	$(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)

data/vendor/scs/README.md

@@ -8,7 +8,7 @@
 
 
 SCS (`splitting conic solver`) is a numerical optimization package for solving
-large-scale convex cone problems. The current version is `3.2.7`.
+large-scale convex cone problems. The current version is `3.2.8`.
 
 The full documentation is available [here](https://www.cvxgrp.org/scs/).
 

data/vendor/scs/include/cones.h

@@ -11,6 +11,17 @@ extern "C" {
 #include "scs_work.h"
 #include <string.h>
 
+#ifdef USE_SPECTRAL_CONES
+#include "util_spectral_cones.h" // for newton_stats
+
+// macro for time measurements of SpectralSCS
+#ifdef SPECTRAL_TIMING_FLAG
+#define SPECTRAL_TIMING(action) action
+#else
+#define SPECTRAL_TIMING(action)
+#endif
+#endif
+
 /* private data to help cone projection step */
 struct SCS_CONE_WORK {
   /*
@@ -26,10 +37,44 @@ struct SCS_CONE_WORK {
   scs_int m;            /* total length of cone */
   /* box cone quantities */
   scs_float box_t_warm_start;
+
 #ifdef USE_LAPACK
   /* workspace for eigenvector decompositions: */
-  scs_float *Xs, *Z, *e, *work;
-  blas_int lwork;
+  scs_float *Xs, *Z, *e, *work, *rwork;
+  scs_complex_float *cXs, *cZ, *cwork;
+  blas_int *isuppz, *iwork;
+  blas_int lwork, lcwork, lrwork, liwork;
+#endif
+
+#ifdef USE_SPECTRAL_CONES
+  /* if the projection onto the logarithmic cone should be warmstarted*/
+  bool *log_cone_warmstarts;
+
+  /* Needed for ell1 norm cone projection */
+  Value_index *work_ell1;
+  scs_float *work_ell1_proj;
+
+  // 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;)
+
+  /* workspace for singular value decompositions: */
+  scs_float *s_nuc, *u_nuc, *vt_nuc, *work_nuc;
+  blas_int lwork_nuc;
+
+  /* workspace that is used internally in the logdet projection (for example,
+     the gradient and Hessian of the objective function in the projection
+     problem are stored using this memory) */
+  scs_float *work_logdet;
+
+  /* workspace to store the projection onto the logarithm cone */
+  scs_float *saved_log_projs;
+
+  /* Stats for spectral projections, assuming there is only one spectral cone */
+  Newton_stats newton_stats;
+
+  /* workspace for projection onto sum-largest-evals cone */
+  scs_float *work_sum_of_largest;
 #endif
 };
 

data/vendor/scs/include/glbopts.h

@@ -14,7 +14,7 @@ extern "C" {
 
 /* SCS VERSION NUMBER ----------------------------------------------     */
 /* string literals automatically null-terminated */
-#define SCS_VERSION ("3.2.7")
+#define SCS_VERSION ("3.2.8")
 
 /* verbosity level */
 #ifndef VERBOSITY

data/vendor/scs/include/scs.h

@@ -130,6 +130,10 @@ typedef struct {
   scs_int *s;
   /** Length of semidefinite constraints array `s`. */
   scs_int ssize;
+  /** Array of complex semidefinite cone constraints, `len(cs) = cssize`. */
+  scs_int *cs;
+  /** Length of complex semidefinite constraints array `cs`. */
+  scs_int cssize;
   /** Number of primal exponential cone triples. */
   scs_int ep;
   /** Number of dual exponential cone triples. */
@@ -139,6 +143,24 @@ typedef struct {
   scs_float *p;
   /** Number of (primal and dual) power cone triples. */
   scs_int psize;
+#ifdef USE_SPECTRAL_CONES
+  /** Array of logdet cone constraints 'len(d) = dsize'. The dimension of a
+   * log-det cone is "n" and not "n+2" if the matrix has dimension n */
+  scs_int *d;
+  /** Length of logdet cone constraints array `d`. */
+  scs_int dsize;
+  /** Array of nuc norm cone constraints 'len(nuc_m) = len(nuc_n) = nucsize.*/
+  scs_int *nuc_m;
+  scs_int *nuc_n;
+  scs_int nucsize;
+  /** Array of ell1-norm cone constraints 'len(ell1) = ell1_size */
+  scs_int *ell1;
+  scs_int ell1_size;
+  /** Array of sum-of-largest-evals cone  */
+  scs_int *sl_n;
+  scs_int *sl_k;
+  scs_int sl_size;
+#endif
 } ScsCone;
 
 /** Contains primal-dual solution arrays or a certificate of infeasibility.
@@ -202,6 +224,13 @@ typedef struct {
   scs_float cone_time;
   /** Total time (milliseconds) spent in the acceleration routine. */
   scs_float accel_time;
+#ifdef SPECTRAL_TIMING_FLAG
+  /** Average time (milliseconds) per iteration matrix cone projection */
+  scs_float ave_time_matrix_cone_proj;
+  /** Average time (milliseconds) per iteration for spectral vector cone
+   * projection */
+  scs_float ave_time_vector_cone_proj;
+#endif
 } ScsInfo;
 
 /*

data/vendor/scs/include/scs_blas.h

@@ -18,9 +18,11 @@ extern "C" {
 #ifndef SFLOAT
 #define BLAS(x) d##x
 #define BLASI(x) id##x
+#define BLASC(x) z##x
 #else
 #define BLAS(x) s##x
 #define BLASI(x) is##x
+#define BLASC(x) c##x
 #endif
 #else
 /* this extra indirection is needed for BLASSUFFIX to work correctly as a
@@ -31,9 +33,11 @@ extern "C" {
 #ifndef SFLOAT
 #define BLAS(x) stitch__(d, x, BLASSUFFIX)
 #define BLASI(x) stitch__(id, x, BLASSUFFIX)
+#define BLASC(x) stitch__(z, x, BLASSUFFIX)
 #else
 #define BLAS(x) stitch__(s, x, BLASSUFFIX)
 #define BLASI(x) stitch__(is, x, BLASSUFFIX)
+#define BLASC(x) stitch__(c, x, BLASSUFFIX)
 #endif
 #endif
 

data/vendor/scs/include/scs_types.h

@@ -1,5 +1,5 @@
 /*
- * Pulic header including definitions of primitive types used in SCS.
+ * Public header including definitions of primitive types used in SCS.
  * Make sure this file and `scs.h` are somewhere appropriate and then use
  * `#include "scs.h"` to access the SCS public API.
  */
@@ -26,8 +26,10 @@ typedef int scs_int;
 
 #ifndef SFLOAT
 typedef double scs_float;
+typedef double scs_complex_float[2]; // [real, imaginary]
 #else
 typedef float scs_float;
+typedef float scs_complex_float[2]; // [real, imaginary]
 #endif
 
 #ifdef __cplusplus

data/vendor/scs/include/util_spectral_cones.h

@@ -0,0 +1,45 @@
+#ifndef UTILSPECTRALCONES_H
+#define UTILSPECTRALCONES_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "scs_blas.h"
+#include "scs_types.h"
+#include <assert.h>
+#include <math.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdio.h>
+
+#define IN_CONE -1
+#define IN_NEGATIVE_DUAL_CONE -2
+#define ANALYTICAL_SOL -3
+
+bool is_pos(const scs_float *x, scs_int n);
+bool is_negative(const scs_float *x, scs_int n);
+void non_neg_proj(const scs_float *src, scs_float *dst, scs_int n);
+scs_float sum_log(const scs_float *x, scs_int n);
+scs_float min_vec(const scs_float *vec, scs_int n);
+
+// used for sorting in ell1-norm cone and sum of largest cone.
+typedef struct {
+  scs_float value;
+  int index;
+} Value_index;
+
+typedef struct {
+  int iter;
+
+  // if plain Newton computed the projection or if an IPM was used
+  int newton_success;
+
+  // dual_res, pri_res, complementarity for the projection problem
+  scs_float residuals[3];
+} Newton_stats;
+
+#ifdef __cplusplus
+}
+#endif
+#endif

data/vendor/scs/linsys/cpu/direct/private.c

@@ -51,7 +51,7 @@ static scs_int ldl_prepare(ScsLinSysWork *p) {
   L->i = (scs_int *)scs_calloc(nzmax, sizeof(scs_int));
   p->Dinv = (scs_float *)scs_calloc(n, sizeof(scs_float));
   p->D = (scs_float *)scs_calloc(n, sizeof(scs_float));
-  p->bwork = (scs_int *)scs_calloc(n, sizeof(scs_int));
+  p->bwork = (QDLDL_bool *)scs_calloc(n, sizeof(QDLDL_bool));
   p->fwork = (scs_float *)scs_calloc(n, sizeof(scs_float));
   return nzmax;
 }
@@ -143,7 +143,7 @@ static ScsMatrix *cs_symperm(const ScsMatrix *A, const scs_int *pinv,
       i = Ai[p];
       if (i > j) {
         continue;
-      }                        /* skip lower triangular part of A */
+      } /* skip lower triangular part of A */
       i2 = pinv ? pinv[i] : i; /* row i of A is row i2 of C */
       w[MAX(i2, j2)]++;        /* column count of C */
     }
@@ -155,7 +155,7 @@ static ScsMatrix *cs_symperm(const ScsMatrix *A, const scs_int *pinv,
       i = Ai[p];
       if (i > j) {
         continue;
-      }                        /* skip lower triangular part of A*/
+      } /* skip lower triangular part of A*/
       i2 = pinv ? pinv[i] : i; /* row i of A is row i2 of C */
       Ci[q = w[MAX(i2, j2)]++] = MIN(i2, j2);
       if (Cx) {

data/vendor/scs/linsys/cpu/direct/private.h

@@ -22,7 +22,8 @@ struct SCS_LIN_SYS_WORK {
   scs_int factorizations;
   /* ldl factorization workspace */
   scs_float *D, *fwork;
-  scs_int *etree, *iwork, *Lnz, *bwork;
+  scs_int *etree, *iwork, *Lnz;
+  QDLDL_bool *bwork;
   scs_float *diag_p;
 };
 

data/vendor/scs/linsys/csparse.c

@@ -7,7 +7,7 @@ ScsMatrix *SCS(cs_spalloc)(scs_int m, scs_int n, scs_int nzmax, scs_int values,
   ScsMatrix *A = (ScsMatrix *)scs_calloc(1, sizeof(ScsMatrix));
   if (!A) {
     return SCS_NULL;
-  }         /* out of memory */
+  } /* out of memory */
   A->m = m; /* define dimensions and nzmax */
   A->n = n;
   A->p = (scs_int *)scs_calloc((triplet ? nzmax : n + 1), sizeof(scs_int));