scs 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cf0730fd042983c36ce96ea46ad28c0a330c5765e1521f8cfb28eb3321507df9
-  data.tar.gz: 677ebb1dc72dc2c1e51857c8644a11e91f9a332c95574ee8c452e31f36f4ec88
+  metadata.gz: '0578a2b207262c394530743edb4943b8c1e17d8b56e890f7127bc1db29d74a39'
+  data.tar.gz: '099d565be542333322a4a7fad5fd5b45d6ce16f3c6bedd1335ed92c8f534842d'
 SHA512:
-  metadata.gz: 889d538aba521314bc093e11fc584eb58f519116f72fedcab865b9a49a44fec44eaffbc20e28d1f2673c294922474c7ccc91f7ee7f0b08243c9e20ae52150e3c
-  data.tar.gz: 25ca5f1af62a227f1f05c34031d8f1554e1b9121c2d8c43bb40c4bd12d0af5d106b73a601f8abb8a3849fbdcde310b51a2fecfe17bb9e4bba4d3a70e5fd59fff
+  metadata.gz: 2fc5791159501b367a295502936c6696a0d170a86ecc07e1c4937d3e7030f8759cdf6df988dea2ccb14cb444e931cc390dcc4cecc7e31b5714f97dc62e3b2e40
+  data.tar.gz: da1556dc4a0430bf772955cf7e91da186d2df43f6a52765a13cba95c3b75a895bb76b8408ecb4f8ae77f427d3b026a5517fa8bbe81ed4e896286eea7ca4414bc

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.2.3 (2021-09-09)
+
+- Updated SCS to 2.1.4
+
 ## 0.2.2 (2020-07-21)
 
 - Updated SCS to 2.1.2

data/LICENSE.txt

@@ -1,22 +1,22 @@
-Copyright (c) 2019-2020 Andrew Kane
+The MIT License (MIT)
 
-MIT License
+Copyright (c) 2012 Brendan O'Donoghue (bodonoghue85@gmail.com)
+Copyright (c) 2019-2021 Andrew Kane
 
-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:
+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 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.
+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/README.md

@@ -4,7 +4,7 @@
 
 :fire: Supports many different [problem types](https://www.cvxpy.org/tutorial/advanced/index.html#choosing-a-solver)
 
-[![Build Status](https://travis-ci.org/ankane/scs.svg?branch=master)](https://travis-ci.org/ankane/scs) [![Build status](https://ci.appveyor.com/api/projects/status/wyn0cbgs0k5vg5tq/branch/master?svg=true)](https://ci.appveyor.com/project/ankane/scs/branch/master)
+[![Build Status](https://github.com/ankane/scs/workflows/build/badge.svg?branch=master)](https://github.com/ankane/scs/actions)
 
 ## Installation
 

data/lib/scs/version.rb

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

data/vendor/scs/CMakeLists.txt

@@ -0,0 +1,273 @@
+# CMakeLists.txt file for scs
+# This software may be modified and distributed under the terms of the MIT License
+
+cmake_minimum_required(VERSION 3.5)
+
+project(scs
+  LANGUAGES C
+  VERSION 2.1.4)
+
+# Defines the CMAKE_INSTALL_LIBDIR, CMAKE_INSTALL_BINDIR and many other useful macros.
+# See https://cmake.org/cmake/help/latest/module/GNUInstallDirs.html
+include(GNUInstallDirs)
+
+# Control where libraries and executables are placed during the build.
+# With the following settings executables are placed in <the top level of the
+# build tree>/bin and libraries/archives in <top level of the build tree>/lib.
+# This is particularly useful to run ctests on libraries built on Windows
+# machines: tests, which are executables, are placed in the same folders of
+# dlls, which are treated as executables as well, so that they can properly
+# find the libraries to run. This is a because of missing RPATH on Windows.
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_BINDIR}")
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}")
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}")
+
+# To build shared libraries in Windows, we set CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS to TRUE.
+# See https://cmake.org/cmake/help/v3.4/variable/CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS.html
+# See https://blog.kitware.com/create-dlls-on-windows-without-declspec-using-new-cmake-export-all-feature/
+set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
+
+# Under MSVC, we set CMAKE_DEBUG_POSTFIX to "d" to add a trailing "d" to library
+# built in debug mode. In this Windows user can compile, build and install the
+# library in both Release and Debug configuration avoiding naming clashes in the
+# installation directories.
+if(MSVC)
+  set(CMAKE_DEBUG_POSTFIX "d")
+endif()
+
+# Build position independent code.
+# Position Independent Code (PIC) is commonly used for shared libraries so that
+# the same shared library code can be loaded in each program address space in a
+# location where it will not overlap with any other uses of such memory.
+# In particular, this option avoids problems occurring when a process wants to
+# load more than one shared library at the same virtual address.
+# Since shared libraries cannot predict where other shared libraries could be
+# loaded, this is an unavoidable problem with the traditional shared library
+# concept.
+# Generating position-independent code is often the default behavior for most
+# modern compilers.
+# Moreover linking a static library that is not built with PIC from a shared
+# library will fail on some compiler/architecture combinations.
+# Further details on PIC can be found here:
+# https://eli.thegreenplace.net/2011/11/03/position-independent-code-pic-in-shared-libraries/
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+# Disable C and C++ compiler extensions.
+# C/CXX_EXTENSIONS are ON by default to allow the compilers to use extended
+# variants of the C/CXX language.
+# However, this could expose cross-platform bugs in user code or in the headers
+# of third-party dependencies and thus it is strongly suggested to turn
+# extensions off.
+set(CMAKE_C_EXTENSIONS OFF)
+set(CMAKE_CXX_EXTENSIONS OFF)
+list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
+
+### Options
+# Shared/Dynamic or Static library?
+option(BUILD_SHARED_LIBS "Build libraries as shared as opposed to static" ON)
+
+# Enable RPATH support for installed binaries and libraries
+include(AddInstallRPATHSupport)
+add_install_rpath_support(BIN_DIRS "${CMAKE_INSTALL_FULL_BINDIR}"
+  LIB_DIRS "${CMAKE_INSTALL_FULL_LIBDIR}"
+  INSTALL_NAME_DIR "${CMAKE_INSTALL_FULL_LIBDIR}"
+  USE_LINK_PATH)
+
+# Encourage user to specify a build type (e.g. Release, Debug, etc.), otherwise set it to Release.
+if(NOT CMAKE_CONFIGURATION_TYPES)
+  if(NOT CMAKE_BUILD_TYPE)
+    message(STATUS "Setting build type to 'Release' as none was specified.")
+    set_property(CACHE CMAKE_BUILD_TYPE PROPERTY VALUE "Release")
+  endif()
+endif()
+
+
+# Build test related commands?
+option(BUILD_TESTING "Create tests using CMake" OFF)
+if(BUILD_TESTING)
+  enable_testing()
+endif()
+
+### Some variables useful for sampling the building process
+# Note that the GPU profile is not compiled.
+set(LINSYS linsys)
+set(DIRSRC ${LINSYS}/cpu/direct)
+set(INDIRSRC ${LINSYS}/cpu/indirect)
+set(EXTERNAL ${LINSYS}/external)
+
+
+# Common source files
+set(${PROJECT_NAME}_SRC
+  src/aa.c
+  src/cones.c
+  src/ctrlc.c
+  src/linalg.c
+  src/normalize.c
+  src/rw.c
+  src/scs.c
+  src/scs_version.c
+  src/util.c
+  ${LINSYS}/amatrix.c)
+
+# Common header files
+set(${PROJECT_NAME}_HDR
+  include/aa.h
+  include/cones.h
+  include/ctrlc.h
+  include/glbopts.h
+  include/linalg.h
+  include/linsys.h
+  include/normalize.h
+  include/rw.h
+  include/scs.h
+  include/scs_blas.h
+  include/util.h
+  ${LINSYS}/amatrix.h)
+
+# get all the c file in amd/external
+file(GLOB ${PROJECT_NAME}_AMD_EXTERNAL_SRC
+  ${EXTERNAL}/amd/*.c
+  )
+
+# get all the h file in amd/external
+file(GLOB ${PROJECT_NAME}_AMD_EXTERNAL_HDR
+  ${EXTERNAL}/amd/*.h
+  )
+
+# get all the c file in amd/external
+file(GLOB ${PROJECT_NAME}_LDL_EXTERNAL_HDR
+  ${EXTERNAL}/qdldl/*.h
+  )
+
+### Direct method
+# Here we compile the direct method library
+set(${PROJECT_NAME}_DIRECT ${PROJECT_NAME}dir)
+add_library(${${PROJECT_NAME}_DIRECT}
+  ${${PROJECT_NAME}_HDR}
+  ${${PROJECT_NAME}_SRC}
+  ${DIRSRC}/private.c
+  ${DIRSRC}/private.h
+  ${EXTERNAL}/qdldl/qdldl.c
+  ${${PROJECT_NAME}_AMD_EXTERNAL_SRC}
+  ${${PROJECT_NAME}_AMD_EXTERNAL_HDR}
+  ${${PROJECT_NAME}_LDL_EXTERNAL_HDR})
+
+target_include_directories(${${PROJECT_NAME}_DIRECT} PRIVATE
+  "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/${EXTERNAL}/amd;${CMAKE_CURRENT_SOURCE_DIR}/${EXTERNAL}/qdldl;${CMAKE_CURRENT_SOURCE_DIR}/${DIRSRC};${CMAKE_CURRENT_SOURCE_DIR}/${LINSYS}>")
+
+target_include_directories(${${PROJECT_NAME}_DIRECT} PUBLIC
+  "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
+  "$<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)
+
+# The library depends on math (m) blas and lapack
+target_link_libraries(${${PROJECT_NAME}_DIRECT} PRIVATE
+  m
+  blas
+  lapack)
+
+# Set some properties
+set_target_properties(${${PROJECT_NAME}_DIRECT} PROPERTIES
+  VERSION ${scs_VERSION}
+  PUBLIC_HEADER "${${PROJECT_NAME}_HDR}")
+
+add_library(scs::${${PROJECT_NAME}_DIRECT} ALIAS ${${PROJECT_NAME}_DIRECT})
+
+# Install the library
+install(TARGETS ${${PROJECT_NAME}_DIRECT}
+  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 direct method to the set of the compiled targets
+set_property(GLOBAL APPEND PROPERTY scs_TARGETS ${${PROJECT_NAME}_DIRECT})
+
+### Indirect method
+# Here we compile the indirect method library
+set(${PROJECT_NAME}_INDIRECT ${PROJECT_NAME}indir)
+add_library(${${PROJECT_NAME}_INDIRECT}
+  ${${PROJECT_NAME}_HDR}
+  ${${PROJECT_NAME}_SRC}
+  ${INDIRSRC}/private.c
+  ${${${PROJECT_NAME}_INDIRECT}_HDR}
+  ${EXTERNAL}/qdldl/qdldl.c
+  ${${PROJECT_NAME}_AMD_EXTERNAL_SRC}
+  ${${PROJECT_NAME}_AMD_EXTERNAL_HDR}
+  ${${PROJECT_NAME}_LDL_EXTERNAL_SRC}
+  )
+
+
+target_include_directories(${${PROJECT_NAME}_INDIRECT} PRIVATE
+  "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/${EXTERNAL}/amd;${CMAKE_CURRENT_SOURCE_DIR}/${EXTERNAL}/qdldl;${CMAKE_CURRENT_SOURCE_DIR}/${INDIRSRC};${CMAKE_CURRENT_SOURCE_DIR}/${LINSYS}>")
+
+target_include_directories(${${PROJECT_NAME}_INDIRECT} PUBLIC
+  "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
+  "$<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)
+
+# The library depends on math (m) blas and lapack
+target_link_libraries(${${PROJECT_NAME}_INDIRECT} PUBLIC
+  m
+  blas
+  lapack)
+
+# Set some properties
+set_target_properties(${${PROJECT_NAME}_INDIRECT} PROPERTIES
+  VERSION ${scs_VERSION}
+  PUBLIC_HEADER "${${${PROJECT_NAME}_INDIRECT}_HDR}")
+
+add_library(scs::${${PROJECT_NAME}_INDIRECT} ALIAS ${${PROJECT_NAME}_INDIRECT})
+
+# Install the library
+install(TARGETS ${${PROJECT_NAME}_INDIRECT}
+  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 indirect method to the set of the compiled targets
+set_property(GLOBAL APPEND PROPERTY scs_TARGETS ${${PROJECT_NAME}_INDIRECT})
+
+### Install the .cmake file.
+# Thanks to thanks file it will be possible to link scs to consumer libraries
+include(InstallBasicPackageFiles)
+install_basic_package_files(${PROJECT_NAME}
+  NAMESPACE scs::
+  VERSION ${${PROJECT_NAME}_VERSION}
+  TARGETS_PROPERTY scs_TARGETS
+  COMPATIBILITY SameMajorVersion
+  VARS_PREFIX ${PROJECT_NAME}
+  NO_CHECK_REQUIRED_COMPONENTS_MACRO)
+
+### Add the tests
+if(BUILD_TESTING)
+  add_executable(run_tests_direct  test/run_tests.c)
+  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}>")
+
+  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_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}>")
+
+  add_test(NAME run_tests_indirect
+    COMMAND run_tests_indirect
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+
+endif()

data/vendor/scs/README.md

@@ -1,8 +1,9 @@
-SCS
-====
+<h1 align="center" margin=0px>
+<img src="https://github.com/cvxgrp/scs/blob/master/docs/scs_logo.png" alt="Intersection of a cone and a polyhedron" width="450">
+</h1>
+
+![Build Status](https://github.com/cvxgrp/scs/actions/workflows/build.yml/badge.svg)
 
-[![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
@@ -18,10 +19,11 @@ 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
+[Convex.jl](https://github.com/jump-dev/Convex.jl),
+[JuMP.jl](https://github.com/jump-dev/JuMP.jl), and
 [Yalmip](https://github.com/johanlofberg/YALMIP).
 
-The current version is `2.1.2`. If you wish to cite SCS, please use the
+The current version is `2.1.4`. If you wish to cite SCS, please use the
 following:
 ```
 @article{ocpb:16,
@@ -37,7 +39,7 @@ following:
 }
 @misc{scs,
     author       = {B. O'Donoghue and E. Chu and N. Parikh and S. Boyd},
-    title        = {{SCS}: Splitting Conic Solver, version 2.1.2},
+    title        = {{SCS}: Splitting Conic Solver, version 2.1.4},
     howpublished = {\url{https://github.com/cvxgrp/scs}},
     month        = nov,
     year         = 2019
@@ -137,7 +139,7 @@ gpu.
 
 The direct solver uses external numerical linear algebra packages:
 * [QDLDL](https://github.com/oxfordcontrol/qdldl)
-* [AMD](http://www.cise.ufl.edu/research/sparse/).
+* [AMD](https://github.com/DrTimothyAldenDavis/SuiteSparse).
 
 ### Using SCS in C
 Typing `make` at the command line will compile the code and create SCS libraries
@@ -153,7 +155,7 @@ If `make` completes successfully, it will produce two static library files,
 `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
+installed, you can also execute `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`.
@@ -220,3 +222,49 @@ two structs in `include/linsys.h` and plug it in.
 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.
+
+### Using SCS with cmake
+
+Thanks to [`CMake`](http://cmake.org) buildsystem, scs can be easily compiled
+and linked by other `CMake` projects. To use the `cmake` buld system please run
+the following commands:
+```
+cd scs
+mkdir build
+cd build
+cmake -DCMAKE_INSTALL_PREFIX:PATH=<custom-folder> ../
+make
+make install
+```
+
+You may also want to compile the tests. In this case when you configure the project,
+please call the following command
+```
+cmake -DCMAKE_INSTALL_PREFIX:PATH=<custom-folder> -DBUILD_TESTING=ON ../
+make
+ctest
+```
+
+By default the build-system will compile the library as `shared`. If you want to
+compile it as `static`, please call the following command when you configure the
+project
+```
+cmake -DCMAKE_INSTALL_PREFIX:PATH=<custom-folder> -BUILD_SHARED_LIBS=OFF ../
+make
+```
+
+The `cmake` build-system exports two CMake targets called `scs::scsdir` and
+`scs::scsindir` which can be imported using the `find_package` CMake command
+and used by calling `target_link_libraries` as in the following example:
+```cmake
+cmake_minimum_required(VERSION 3.0)
+project(myproject)
+find_package(scs REQUIRED)
+add_executable(example example.cpp)
+
+# To use the direct method
+target_link_libraries(example scs::scsdir)
+
+# To use the indirect method
+target_link_libraries(example scs::scsindir)
+```

data/vendor/scs/include/glbopts.h

@@ -13,7 +13,7 @@ extern "C" {
 
 /* SCS VERSION NUMBER ----------------------------------------------    */
 #define SCS_VERSION \
-  ("2.1.2") /* string literals automatically null-terminated */
+  ("2.1.4") /* string literals automatically null-terminated */
 
 /* SCS returns one of the following integers:                           */
 #define SCS_INFEASIBLE_INACCURATE (-7)

data/vendor/scs/linsys/gpu/gpu.c

@@ -1,33 +1,72 @@
 #include "gpu.h"
 
-void SCS(_accum_by_atrans_gpu)(const ScsGpuMatrix *Ag, const scs_float *x,
-                               scs_float *y, cusparseHandle_t cusparse_handle) {
+void SCS(_accum_by_atrans_gpu)(const ScsGpuMatrix *Ag, const cusparseDnVecDescr_t x,
+                               cusparseDnVecDescr_t y, cusparseHandle_t cusparse_handle,
+                               size_t *buffer_size, void **buffer) {
   /* y += A'*x
      x and y MUST be on GPU already
   */
   const scs_float onef = 1.0;
-  CUSPARSE(csrmv)
-  (cusparse_handle, CUSPARSE_OPERATION_NON_TRANSPOSE, Ag->n, Ag->m, Ag->Annz,
-   &onef, Ag->descr, Ag->x, Ag->p, Ag->i, x, &onef, y);
+  size_t new_buffer_size = 0;
+
+  CUSPARSE_GEN(SpMV_bufferSize)
+  (cusparse_handle, CUSPARSE_OPERATION_NON_TRANSPOSE,
+    &onef, Ag->descr, x, &onef, y,
+    SCS_CUDA_FLOAT, SCS_CSRMV_ALG,
+    &new_buffer_size);
+
+  if (new_buffer_size > *buffer_size) {
+    if (*buffer != SCS_NULL) {
+      cudaFree(*buffer);
+    }
+    cudaMalloc(buffer, *buffer_size);
+    *buffer_size = new_buffer_size;
+  }
+
+  CUSPARSE_GEN(SpMV)
+  (cusparse_handle, CUSPARSE_OPERATION_NON_TRANSPOSE,
+    &onef, Ag->descr, x, &onef, y,
+    SCS_CUDA_FLOAT, SCS_CSRMV_ALG,
+    buffer);
 }
 
-void SCS(_accum_by_a_gpu)(const ScsGpuMatrix *Ag, const scs_float *x,
-                          scs_float *y, cusparseHandle_t cusparse_handle) {
+void SCS(_accum_by_a_gpu)(const ScsGpuMatrix *Ag, const cusparseDnVecDescr_t x,
+                          cusparseDnVecDescr_t y, cusparseHandle_t cusparse_handle,
+                          size_t *buffer_size, void **buffer) {
   /* y += A*x
      x and y MUST be on GPU already
    */
   const scs_float onef = 1.0;
+  size_t new_buffer_size = 0;
+
   /* The A matrix idx pointers must be ORDERED */
-  CUSPARSE(csrmv)
-  (cusparse_handle, CUSPARSE_OPERATION_TRANSPOSE, Ag->n, Ag->m, Ag->Annz, &onef,
-   Ag->descr, Ag->x, Ag->p, Ag->i, x, &onef, y);
+
+  CUSPARSE_GEN(SpMV_bufferSize)
+  (cusparse_handle, CUSPARSE_OPERATION_TRANSPOSE,
+    &onef, Ag->descr, x, &onef, y,
+    SCS_CUDA_FLOAT, SCS_CSRMV_ALG,
+    &new_buffer_size);
+
+  if (new_buffer_size > *buffer_size) {
+    if (*buffer != SCS_NULL) {
+      cudaFree(*buffer);
+    }
+    cudaMalloc(buffer, *buffer_size);
+    *buffer_size = new_buffer_size;
+  }
+
+  CUSPARSE_GEN(SpMV)
+  (cusparse_handle, CUSPARSE_OPERATION_TRANSPOSE,
+    &onef, Ag->descr, x, &onef, y,
+    SCS_CUDA_FLOAT, SCS_CSRMV_ALG,
+    buffer);
 }
 
 void SCS(free_gpu_matrix)(ScsGpuMatrix *A) {
   cudaFree(A->x);
   cudaFree(A->i);
   cudaFree(A->p);
-  cusparseDestroyMatDescr(A->descr);
+  cusparseDestroySpMat(A->descr);
 }
 
 void SCS(normalize_a)(ScsMatrix *A, const ScsSettings *stgs, const ScsCone *k,

data/vendor/scs/linsys/gpu/gpu.h

@@ -34,6 +34,7 @@ extern "C" {
 #define CUBLAS(x) cublasS##x
 #define CUSPARSE(x) cusparseS##x
 #endif
+#define CUSPARSE_GEN(x) cusparse##x
 #else
 #ifndef SFLOAT
 #define CUBLAS(x) \
@@ -50,8 +51,26 @@ extern "C" {
   CUDA_CHECK_ERR;   \
   cusparseS##x
 #endif
+#define CUSPARSE_GEN(x) \
+  CUDA_CHECK_ERR;       \
+  cusparse##x
 #endif
 
+#ifndef SFLOAT
+#define SCS_CUDA_FLOAT CUDA_R_64F
+#else
+#define SCS_CUDA_FLOAT CUDA_R_32F
+#endif
+
+#ifndef DLONG
+#define SCS_CUSPARSE_INDEX CUSPARSE_INDEX_32I
+#else
+#define SCS_CUSPARSE_INDEX CUSPARSE_INDEX_64I
+#endif
+
+#define SCS_CSRMV_ALG CUSPARSE_CSRMV_ALG1
+#define SCS_CSR2CSC_ALG CUSPARSE_CSR2CSC_ALG1
+
 /*
  CUDA matrix routines only for CSR, not CSC matrices:
     CSC             CSR             GPU     Mult
@@ -68,14 +87,16 @@ typedef struct SCS_GPU_A_DATA_MATRIX {
   scs_int m, n; /* m rows, n cols */
   scs_int Annz; /* num non-zeros in A matrix */
   /* CUDA */
-  cusparseMatDescr_t descr;
+  cusparseSpMatDescr_t descr;
 } ScsGpuMatrix;
 
-void SCS(_accum_by_atrans_gpu)(const ScsGpuMatrix *A, const scs_float *x,
-                               scs_float *y, cusparseHandle_t cusparse_handle);
+void SCS(_accum_by_atrans_gpu)(const ScsGpuMatrix *A, const cusparseDnVecDescr_t x,
+                               cusparseDnVecDescr_t y, cusparseHandle_t cusparse_handle,
+                               size_t *buffer_size, void **buffer);
 
-void SCS(_accum_by_a_gpu)(const ScsGpuMatrix *A, const scs_float *x,
-                          scs_float *y, cusparseHandle_t cusparse_handle);
+void SCS(_accum_by_a_gpu)(const ScsGpuMatrix *A, const cusparseDnVecDescr_t x,
+                          cusparseDnVecDescr_t y, cusparseHandle_t cusparse_handle,
+                          size_t *buffer_size, void **buffer);
 
 void SCS(free_gpu_matrix)(ScsGpuMatrix *A);
 

data/vendor/scs/linsys/gpu/indirect/private.c

@@ -10,7 +10,14 @@ void SCS(accum_by_atrans)(const ScsMatrix *A, ScsLinSysWork *p,
   scs_float *v_n = p->r;
   cudaMemcpy(v_m, x, A->m * sizeof(scs_float), cudaMemcpyHostToDevice);
   cudaMemcpy(v_n, y, A->n * sizeof(scs_float), cudaMemcpyHostToDevice);
-  SCS(_accum_by_atrans_gpu)(p->Ag, v_m, v_n, p->cusparse_handle);
+
+  cusparseDnVecSetValues(p->dn_vec_m, (void *) v_m);
+  cusparseDnVecSetValues(p->dn_vec_n, (void *) v_n);
+  SCS(_accum_by_atrans_gpu)(
+    p->Ag, p->dn_vec_m, p->dn_vec_n, p->cusparse_handle,
+    &p->buffer_size, &p->buffer
+  );
+
   cudaMemcpy(y, v_n, A->n * sizeof(scs_float), cudaMemcpyDeviceToHost);
 }
 
@@ -21,11 +28,21 @@ void SCS(accum_by_a)(const ScsMatrix *A, ScsLinSysWork *p, const scs_float *x,
   scs_float *v_n = p->r;
   cudaMemcpy(v_n, x, A->n * sizeof(scs_float), cudaMemcpyHostToDevice);
   cudaMemcpy(v_m, y, A->m * sizeof(scs_float), cudaMemcpyHostToDevice);
+
+  cusparseDnVecSetValues(p->dn_vec_m, (void *) v_m);
+  cusparseDnVecSetValues(p->dn_vec_n, (void *) v_n);
 #if GPU_TRANSPOSE_MAT > 0
-  SCS(_accum_by_atrans_gpu)(p->Agt, v_n, v_m, p->cusparse_handle);
+  SCS(_accum_by_atrans_gpu)(
+    p->Agt, p->dn_vec_n, p->dn_vec_m, p->cusparse_handle,
+    &p->buffer_size, &p->buffer
+  );
 #else
-  SCS(_accum_by_a_gpu)(p->Ag, v_n, v_m, p->cusparse_handle);
+  SCS(_accum_by_a_gpu)(
+    p->Ag, p->dn_vec_n, p->dn_vec_m, p->cusparse_handle,
+    &p->buffer_size, &p->buffer
+  );
 #endif
+
   cudaMemcpy(y, v_m, A->m * sizeof(scs_float), cudaMemcpyDeviceToHost);
 }
 
@@ -64,6 +81,11 @@ void SCS(free_lin_sys_work)(ScsLinSysWork *p) {
       SCS(free_gpu_matrix)(p->Agt);
       scs_free(p->Agt);
     }
+    if (p->buffer != SCS_NULL) {
+      cudaFree(p->buffer);
+    }
+    cusparseDestroyDnVec(p->dn_vec_m);
+    cusparseDestroyDnVec(p->dn_vec_n);
     cusparseDestroy(p->cusparse_handle);
     cublasDestroy(p->cublas_handle);
     /* Don't reset because it interferes with other GPU programs. */
@@ -78,9 +100,30 @@ static void mat_vec(const ScsGpuMatrix *A, const ScsSettings *s,
   /* x and y MUST already be loaded to GPU */
   scs_float *tmp_m = p->tmp_m; /* temp memory */
   cudaMemset(tmp_m, 0, A->m * sizeof(scs_float));
-  SCS(_accum_by_a_gpu)(A, x, tmp_m, p->cusparse_handle);
+
+  cusparseDnVecSetValues(p->dn_vec_m, (void *) tmp_m);
+  cusparseDnVecSetValues(p->dn_vec_n, (void *) x);
+#if GPU_TRANSPOSE_MAT > 0
+  SCS(_accum_by_atrans_gpu)(
+    p->Agt, p->dn_vec_n, p->dn_vec_m, p->cusparse_handle,
+    &p->buffer_size, &p->buffer
+  );
+#else
+  SCS(_accum_by_a_gpu)(
+    A, p->dn_vec_n, p->dn_vec_m, p->cusparse_handle,
+    &p->buffer_size, &p->buffer
+  );
+#endif
+
   cudaMemset(y, 0, A->n * sizeof(scs_float));
-  SCS(_accum_by_atrans_gpu)(A, tmp_m, y, p->cusparse_handle);
+
+  cusparseDnVecSetValues(p->dn_vec_m, (void *) tmp_m);
+  cusparseDnVecSetValues(p->dn_vec_n, (void *) y);
+  SCS(_accum_by_atrans_gpu)(
+    A, p->dn_vec_m, p->dn_vec_n, p->cusparse_handle,
+    &p->buffer_size, &p->buffer
+  );
+
   CUBLAS(axpy)(p->cublas_handle, A->n, &(s->rho_x), x, 1, y, 1);
 }
 
@@ -112,6 +155,14 @@ ScsLinSysWork *SCS(init_lin_sys_work)(const ScsMatrix *A,
   cudaError_t err;
   ScsLinSysWork *p = (ScsLinSysWork *)scs_calloc(1, sizeof(ScsLinSysWork));
   ScsGpuMatrix *Ag = (ScsGpuMatrix *)scs_malloc(sizeof(ScsGpuMatrix));
+  
+  /* Used for initializing dense vectors */
+  scs_float *tmp_null_n = SCS_NULL;
+  scs_float *tmp_null_m = SCS_NULL;
+
+#if GPU_TRANSPOSE_MAT > 0
+  size_t new_buffer_size = 0;
+#endif
 
   p->cublas_handle = 0;
   p->cusparse_handle = 0;
@@ -119,6 +170,9 @@ ScsLinSysWork *SCS(init_lin_sys_work)(const ScsMatrix *A,
   p->total_solve_time = 0;
   p->tot_cg_its = 0;
 
+  p->buffer_size = 0;
+  p->buffer = SCS_NULL;
+
   /* Get handle to the CUBLAS context */
   cublasCreate(&p->cublas_handle);
 
@@ -130,9 +184,7 @@ ScsLinSysWork *SCS(init_lin_sys_work)(const ScsMatrix *A,
   Ag->Annz = A->p[A->n];
   Ag->descr = 0;
   /* Matrix description */
-  cusparseCreateMatDescr(&Ag->descr);
-  cusparseSetMatType(Ag->descr, CUSPARSE_MATRIX_TYPE_GENERAL);
-  cusparseSetMatIndexBase(Ag->descr, CUSPARSE_INDEX_BASE_ZERO);
+
   p->Ag = Ag;
   p->Agt = SCS_NULL;
 
@@ -155,6 +207,18 @@ ScsLinSysWork *SCS(init_lin_sys_work)(const ScsMatrix *A,
   cudaMemcpy(Ag->x, A->x, (A->p[A->n]) * sizeof(scs_float),
              cudaMemcpyHostToDevice);
 
+  cusparseCreateCsr
+  (&Ag->descr, Ag->n, Ag->m, Ag->Annz, Ag->p, Ag->i, Ag->x,
+    SCS_CUSPARSE_INDEX, SCS_CUSPARSE_INDEX,
+    CUSPARSE_INDEX_BASE_ZERO, SCS_CUDA_FLOAT);
+
+  cudaMalloc((void **)&tmp_null_n, A->n * sizeof(scs_float));
+  cudaMalloc((void **)&tmp_null_m, A->m * sizeof(scs_float));
+  cusparseCreateDnVec(&p->dn_vec_n, Ag->n, tmp_null_n, SCS_CUDA_FLOAT);
+  cusparseCreateDnVec(&p->dn_vec_m, Ag->m, tmp_null_m, SCS_CUDA_FLOAT);
+  cudaFree(tmp_null_n);
+  cudaFree(tmp_null_m);
+
   get_preconditioner(A, stgs, p);
 
 #if GPU_TRANSPOSE_MAT > 0
@@ -164,18 +228,41 @@ ScsLinSysWork *SCS(init_lin_sys_work)(const ScsMatrix *A,
   p->Agt->Annz = A->p[A->n];
   p->Agt->descr = 0;
   /* Matrix description */
-  cusparseCreateMatDescr(&p->Agt->descr);
-  cusparseSetMatType(p->Agt->descr, CUSPARSE_MATRIX_TYPE_GENERAL);
-  cusparseSetMatIndexBase(p->Agt->descr, CUSPARSE_INDEX_BASE_ZERO);
 
   cudaMalloc((void **)&p->Agt->i, (A->p[A->n]) * sizeof(scs_int));
   cudaMalloc((void **)&p->Agt->p, (A->m + 1) * sizeof(scs_int));
   cudaMalloc((void **)&p->Agt->x, (A->p[A->n]) * sizeof(scs_float));
   /* transpose Ag into Agt for faster multiplies */
   /* TODO: memory intensive, could perform transpose in CPU and copy to GPU */
-  CUSPARSE(csr2csc)
-  (p->cusparse_handle, A->n, A->m, A->p[A->n], Ag->x, Ag->p, Ag->i, p->Agt->x,
-   p->Agt->i, p->Agt->p, CUSPARSE_ACTION_NUMERIC, CUSPARSE_INDEX_BASE_ZERO);
+  cusparseCsr2cscEx2_bufferSize
+  (p->cusparse_handle, A->n, A->m, A->p[A->n],
+    Ag->x, Ag->p, Ag->i,
+    p->Agt->x, p->Agt->p, p->Agt->i,
+    SCS_CUDA_FLOAT, CUSPARSE_ACTION_NUMERIC,
+    CUSPARSE_INDEX_BASE_ZERO, SCS_CSR2CSC_ALG,
+    &new_buffer_size);
+
+  if (new_buffer_size > p->buffer_size) {
+    if (p->buffer != SCS_NULL) {
+      cudaFree(p->buffer);
+    }
+    cudaMalloc(&p->buffer, new_buffer_size);
+    p->buffer_size = new_buffer_size;
+  }
+
+  cusparseCsr2cscEx2
+  (p->cusparse_handle, A->n, A->m, A->p[A->n],
+    Ag->x, Ag->p, Ag->i,
+    p->Agt->x, p->Agt->p, p->Agt->i,
+    SCS_CUDA_FLOAT, CUSPARSE_ACTION_NUMERIC,
+    CUSPARSE_INDEX_BASE_ZERO, SCS_CSR2CSC_ALG,
+    p->buffer);
+
+  cusparseCreateCsr
+  (&p->Agt->descr, p->Agt->n, p->Agt->m, p->Agt->Annz,
+    p->Agt->p, p->Agt->i, p->Agt->x,
+    SCS_CUSPARSE_INDEX, SCS_CUSPARSE_INDEX,
+    CUSPARSE_INDEX_BASE_ZERO, SCS_CUDA_FLOAT);
 #endif
 
   err = cudaGetLastError();
@@ -285,11 +372,32 @@ scs_int SCS(solve_lin_sys)(const ScsMatrix *A, const ScsSettings *stgs,
   SCS(tic)(&linsys_timer);
   /* all on GPU */
   cudaMemcpy(bg, b, (Ag->n + Ag->m) * sizeof(scs_float), cudaMemcpyHostToDevice);
-  SCS(_accum_by_atrans_gpu)(Ag, &(bg[Ag->n]), bg, p->cusparse_handle);
+
+  cusparseDnVecSetValues(p->dn_vec_m, (void *) &(bg[Ag->n]));
+  cusparseDnVecSetValues(p->dn_vec_n, (void *) bg);
+  SCS(_accum_by_atrans_gpu)(
+    Ag, p->dn_vec_m, p->dn_vec_n, p->cusparse_handle,
+    &p->buffer_size, &p->buffer
+  );
+
   /* solves (I+A'A)x = b, s warm start, solution stored in b */
   cg_its = pcg(p->Ag, stgs, p, s, bg, Ag->n, MAX(cg_tol, CG_BEST_TOL));
   CUBLAS(scal)(p->cublas_handle, Ag->m, &neg_onef, &(bg[Ag->n]), 1);
-  SCS(_accum_by_a_gpu)(Ag, bg, &(bg[Ag->n]), p->cusparse_handle);
+
+  cusparseDnVecSetValues(p->dn_vec_m, (void *) &(bg[Ag->n]));
+  cusparseDnVecSetValues(p->dn_vec_n, (void *) bg);
+#if GPU_TRANSPOSE_MAT > 0
+  SCS(_accum_by_atrans_gpu)(
+    p->Agt, p->dn_vec_n, p->dn_vec_m, p->cusparse_handle,
+    &p->buffer_size, &p->buffer
+  );
+#else
+  SCS(_accum_by_a_gpu)(
+    Ag, p->dn_vec_n, p->dn_vec_m, p->cusparse_handle,
+    &p->buffer_size, &p->buffer
+  );
+#endif
+
   cudaMemcpy(b, bg, (Ag->n + Ag->m) * sizeof(scs_float), cudaMemcpyDeviceToHost);
 
   if (iter >= 0) {

data/vendor/scs/linsys/gpu/indirect/private.h

@@ -28,6 +28,11 @@ struct SCS_LIN_SYS_WORK {
   /* CUDA */
   cublasHandle_t cublas_handle;
   cusparseHandle_t cusparse_handle;
+  /* CUSPARSE */
+  size_t buffer_size;
+  void *buffer;
+  cusparseDnVecDescr_t dn_vec_m; /* Dense vector of length m */
+  cusparseDnVecDescr_t dn_vec_n; /* Dense vector of length n */
 };
 
 #ifdef __cplusplus

data/vendor/scs/src/rw.c

@@ -37,7 +37,7 @@ static ScsCone *read_scs_cone(FILE *fin) {
   fread(&(k->ep), sizeof(scs_int), 1, fin);
   fread(&(k->ed), sizeof(scs_int), 1, fin);
   fread(&(k->psize), sizeof(scs_int), 1, fin);
-  k->p = scs_calloc(k->psize, sizeof(scs_int));
+  k->p = scs_calloc(k->psize, sizeof(scs_float));
   fread(k->p, sizeof(scs_float), k->psize, fin);
   return k;
 }

metadata

@@ -1,73 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: scs
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - Andrew Kane
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-07-22 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: minitest
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '5'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '5'
-- !ruby/object:Gem::Dependency
-  name: numo-narray
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-description: 
-email: andrew@chartkick.com
+date: 2021-09-09 00:00:00.000000000 Z
+dependencies: []
+description:
+email: andrew@ankane.org
 executables: []
 extensions:
 - ext/scs/extconf.rb
@@ -81,6 +25,7 @@ files:
 - lib/scs/ffi.rb
 - lib/scs/solver.rb
 - lib/scs/version.rb
+- vendor/scs/CMakeLists.txt
 - vendor/scs/LICENSE.txt
 - vendor/scs/Makefile
 - vendor/scs/README.md
@@ -181,7 +126,7 @@ homepage: https://github.com/ankane/scs
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -196,8 +141,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.2.22
+signing_key:
 specification_version: 4
 summary: SCS - the splitting conic solver - for Ruby
 test_files: []