scs 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b9f5ea6b779ddcbadb769df873b68fa590378cb01aa8770fe3e4efebf471f487
-  data.tar.gz: 4e218fccbf2270d438d57f9d7efbd793838a250845d3aae09a1229ca250595bc
+  metadata.gz: 2afa78c52786f5325f64a76edb263b4d30dabab7b15a9415375ed57af861669c
+  data.tar.gz: ae105845b96b30fab4a24bdf3eb2c1f80db7b12d635716ac3c4acfdb17930783
 SHA512:
-  metadata.gz: b58f4154cd9ab36ed7fc152bbe3ccaa9effc9c820b689503289ab31ccf5dbb3304eb6fb6254b5dbc254f621e40c14740297a5e5c30c33e821f905ec50f9ddf3c
-  data.tar.gz: e4f8d67c93889ccdbd5008e97cf4e2875f52dd4209c504eb16bac41b90c942f25cd7312e523fffaed0b35e1c8c6187dd9f858f3c114c73a047ea8ab619525bb8
+  metadata.gz: b8bc74c496d1661b5f14e6da33c79987502d4c320c6789e4cd2d7a4bf118a8800978dc0cd0989f2f9d38978a9d27e14c37d47f8b6bb63ced36af97fee753f5e0
+  data.tar.gz: 5282b6cd3e7f7ed98423ef61eabb1275ce17bdb7b497fab9f7537c53cf7be154d3f1029a170c2c6562bb35780ebceca075e8ca12cd81af163bb7824bb2e91a27

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+## 0.4.0 (2022-07-06)
+
+- Updated SCS to 3.2.0
+- Added `Matrix` class
+- Dropped support for Ruby < 2.7
+
+## 0.3.2 (2022-01-17)
+
+- Updated SCS to 3.1.1
+
+## 0.3.1 (2021-10-08)
+
+- Fixed installation on Linux
+
 ## 0.3.0 (2021-10-05)
 
 - Updated SCS to 3.0.0

data/README.md

@@ -1,28 +1,33 @@
-# 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).
 
 ## Getting Started
 
-Prep the problem
+Prep the problem, like [this one](https://www.cvxgrp.org/scs/examples/python/basic_qp.html)
 
 ```ruby
-data = {a: [[1], [-1]], b: [1, 0], c: [-1]}
-cone = {q: [], l: 2}
+data = {
+  p: SCS::Matrix.from_dense([[3, -1], [-1, 2]]),
+  a: SCS::Matrix.from_dense([[-1, 1], [1, 0], [0, 1]]),
+  b: [-1, 0.3, -0.5],
+  c: [-1, -1]
+}
+cone = {z: 1, l: 2}
 ```
 
 And solve it
@@ -32,12 +37,36 @@ solver = SCS::Solver.new
 solver.solve(data, cone)
 ```
 
+## Data
+
+Matrices can be a sparse matrix
+
+```ruby
+a = SCS::Matrix.new(3, 2)
+a[0, 0] = 1
+a[1, 0] = 2
+# or
+SCS::Matrix.from_dense([[1, 0], [2, 0], [0, 0]])
+```
+
+Arrays can be Ruby arrays
+
+```ruby
+[1, 2, 3]
+```
+
+Or Numo arrays
+
+```ruby
+Numo::NArray.cast([1, 2, 3])
+```
+
 ## Settings
 
 Default values shown
 
 ```ruby
-solver.solve(data, cone, {
+solver.solve(data, cone,
   normalize: true,            # heuristic data rescaling
   scale: 0.1,                 # if normalized, rescales by this factor
   adaptive_scale: true,       # heuristically adapt dual scale through the solve
@@ -54,7 +83,7 @@ solver.solve(data, cone, {
   acceleration_interval: 10,  # iterations to run Anderson acceleration
   write_data_filename: nil,   # filename to write data if set
   log_csv_filename: nil       # write csv logs of various quantities
-})
+)
 ```
 
 ## Direct vs Indirect
@@ -81,22 +110,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/matrix.rb

@@ -0,0 +1,72 @@
+module SCS
+  class Matrix
+    attr_reader :m, :n
+
+    def initialize(m, n)
+      @m = m
+      @n = n
+      @data = {}
+    end
+
+    def []=(row_index, column_index, value)
+      raise IndexError, "row index out of bounds" if row_index < 0 || row_index >= @m
+      raise IndexError, "column index out of bounds" if column_index < 0 || column_index >= @n
+      # dictionary of keys, optimized for converting to CSC
+      # TODO try COO for performance
+      if value == 0
+        (@data[column_index] ||= {}).delete(row_index)
+      else
+        (@data[column_index] ||= {})[row_index] = value
+      end
+    end
+
+    def to_csc
+      cx = []
+      ci = []
+      cp = []
+
+      # CSC format
+      # https://www.gormanalysis.com/blog/sparse-matrix-storage-formats/
+      cp << 0
+      n.times do |j|
+        (@data[j] || {}).sort_by { |k, v| k }.each do |k, v|
+          cx << v
+          ci << k
+        end
+        # cumulative column values
+        cp << cx.size
+      end
+
+      {
+        start: cp,
+        index: ci,
+        value: cx
+      }
+    end
+
+    # private, for tests
+    def nnz
+      @data.sum { |_, v| v.count }
+    end
+
+    def initialize_copy(other)
+      super
+      @data = @data.transform_values(&:dup)
+    end
+
+    def self.from_dense(data)
+      data = data.to_a
+      m = data.size
+      n = m > 0 ? data.first.size : 0
+
+      mtx = Matrix.new(m, n)
+      data.each_with_index do |row, i|
+        raise ArgumentError, "row has different number of columns" if row.size != n
+        row.each_with_index do |v, j|
+          mtx[i, j] = v if v != 0
+        end
+      end
+      mtx
+    end
+  end
+end

data/lib/scs/solver.rb

@@ -73,42 +73,35 @@ module SCS
       char_ptr[0, idx].map(&:chr).join
     end
 
-    # TODO add support sparse matrices
     def csc_matrix(mtx, upper: false)
-      mtx = mtx.to_a
-
-      m, n = shape(mtx)
-
-      cx = []
-      ci = []
-      cp = []
-
-      # CSC format
-      # https://www.gormanalysis.com/blog/sparse-matrix-storage-formats/
-      cp << 0
-      n.times do |j|
-        mtx.each_with_index do |row, i|
-          if row[j] != 0 && (!upper || i <= j)
-            cx << row[j]
-            ci << i
+      mtx = Matrix.from_dense(mtx) unless mtx.is_a?(Matrix)
+
+      if upper
+        # TODO improve performance
+        mtx = mtx.dup
+        mtx.m.times do |i|
+          mtx.n.times do |j|
+            mtx[i, j] = 0 if i > j
           end
         end
-        # cumulative column values
-        cp << cx.size
       end
 
+      csc = mtx.to_csc
+
       # construct matrix
       matrix = ffi::Matrix.malloc
-      matrix.x = float_array(cx)
-      matrix.i = int_array(ci)
-      matrix.p = int_array(cp)
-      matrix.m = m
-      matrix.n = n
+      matrix.x = float_array(csc[:value])
+      matrix.i = int_array(csc[:index])
+      matrix.p = int_array(csc[:start])
+      matrix.m = mtx.m
+      matrix.n = mtx.n
       matrix
     end
 
     def shape(a)
-      if defined?(Matrix) && a.is_a?(Matrix)
+      if a.is_a?(Matrix)
+        [a.m, a.n]
+      elsif defined?(::Matrix) && a.is_a?(::Matrix)
         [a.row_count, a.column_count]
       elsif defined?(Numo::NArray) && a.is_a?(Numo::NArray)
         a.shape
@@ -126,7 +119,7 @@ module SCS
 
       if data[:p]
         raise ArgumentError, "Bad p shape" if shape(data[:p]) != [n, n]
-        cdata.p = csc_matrix(data[:p])
+        cdata.p = csc_matrix(data[:p], upper: true)
       end
 
       raise ArgumentError, "Bad b size" if data[:b].to_a.size != m

data/lib/scs/version.rb

@@ -1,3 +1,3 @@
 module SCS
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/lib/scs.rb

@@ -2,6 +2,7 @@
 require "fiddle/import"
 
 # modules
+require "scs/matrix"
 require "scs/solver"
 require "scs/version"
 

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.2.0
 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.2.0)
 
 # 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 -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,13 @@
 </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.2.0`.
 
 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).

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,10 +18,14 @@ 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;
+  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;
+  scs_float box_t_warm_start;
 #ifdef USE_LAPACK
   /* workspace for eigenvector decompositions: */
   scs_float *Xs, *Z, *e, *work;
@@ -27,18 +33,17 @@ struct SCS_CONE_WORK {
 #endif
 };
 
-ScsConeWork *SCS(init_cone)(const ScsCone *k, const ScsScaling *scal,
-                            scs_int cone_len);
+void SCS(free_cone)(ScsCone *k);
+void 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);
-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
 }