scs 0.2.2 → 0.3.2

data/vendor/scs/CMakeLists.txt

@@ -0,0 +1,320 @@
+# 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 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
+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()
+
+# 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)
+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
+  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}/csparse.c
+  ${LINSYS}/scs_matrix.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/scs_types.h
+  include/scs_work.h
+  include/util.h
+  ${LINSYS}/csparse.h
+  ${LINSYS}/scs_matrix.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 ${COMPILER_OPTS})
+
+# 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}_PUBLIC_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
+  ${INDIRSRC}/private.h
+  ${${${PROJECT_NAME}_INDIRECT}_HDR}
+  )
+
+
+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 ${COMPILER_OPTS} -DINDIRECT)
+
+# 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}_PUBLIC_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_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}>"  )
+
+  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}>"  )
+
+  add_test(NAME run_tests_indirect
+    COMMAND run_tests_indirect
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+
+endif()

data/vendor/scs/Makefile

@@ -1,7 +1,9 @@
 # MAKEFILE for scs
 include scs.mk
 
-SCS_OBJECTS = src/scs.o src/util.o src/cones.o src/aa.o src/rw.o src/linalg.o src/ctrlc.o src/scs_version.o src/normalize.o
+SCS_OBJECTS = src/util.o src/cones.o src/aa.o src/rw.o src/linalg.o src/ctrlc.o src/scs_version.o src/normalize.o
+SCS_O = src/scs.o
+SCS_INDIR_O = src/scs_indir.o
 
 SRC_FILES = $(wildcard src/*.c)
 INC_FILES = $(wildcard include/*.h)
@@ -17,7 +19,7 @@ TARGETS = $(OUT)/demo_socp_indirect $(OUT)/demo_socp_direct $(OUT)/run_from_file
 default: $(TARGETS) $(OUT)/libscsdir.a $(OUT)/libscsindir.a $(OUT)/libscsdir.$(SHARED) $(OUT)/libscsindir.$(SHARED)
 	@echo "****************************************************************************************"
 	@echo "Successfully compiled scs, copyright Brendan O'Donoghue 2012."
-	@echo "To test, type '$(OUT)/demo_socp_indirect' to solve a random SOCP."
+	@echo "To test, type '$(OUT)/demo_socp_direct' to solve a random SOCP."
 	@echo "**********************************************************************************"
 ifneq ($(USE_LAPACK), 0)
 	@echo "Compiled with blas and lapack, can solve LPs, SOCPs, SDPs, ECPs, and PCPs"
@@ -28,38 +30,43 @@ else
 endif
 	@echo "****************************************************************************************"
 
+$(SCS_O): src/scs.c $(INC_FILES)
+	$(CC) $(CFLAGS) -c $< -o $@
+
+$(SCS_INDIR_O): src/scs.c $(INC_FILES)
+	$(CC) $(CFLAGS) -DINDIRECT=1 -c $< -o $@
+
 %.o : src/%.c
 	$(CC) $(CFLAGS) -c $< -o $@
 
-src/scs.o	: $(SRC_FILES) $(INC_FILES)
-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/cs.o	: src/cs.c include/cs.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
-$(LINSYS)/amatrix.o: $(LINSYS)/amatrix.c $(LINSYS)/amatrix.h
+$(LINSYS)/scs_matrix.o: $(LINSYS)/scs_matrix.c $(LINSYS)/scs_matrix.h
+$(LINSYS)/csparse.o: $(LINSYS)/csparse.c $(LINSYS)/csparse.h
 
-$(OUT)/libscsdir.a: $(SCS_OBJECTS) $(DIRSRC)/private.o $(AMD_OBJS) $(LDL_OBJS) $(LINSYS)/amatrix.o
+$(OUT)/libscsdir.a: $(SCS_O) $(SCS_OBJECTS) $(DIRSRC)/private.o $(AMD_OBJS) $(LDL_OBJS) $(LINSYS)/scs_matrix.o $(LINSYS)/csparse.o
 	mkdir -p $(OUT)
 	$(ARCHIVE) $@ $^
 	- $(RANLIB) $@
 
-$(OUT)/libscsindir.a: $(SCS_OBJECTS) $(INDIRSRC)/private.o $(LINSYS)/amatrix.o
+$(OUT)/libscsindir.a: $(SCS_INDIR_O) $(SCS_OBJECTS) $(INDIRSRC)/private.o $(LINSYS)/scs_matrix.o $(LINSYS)/csparse.o
 	mkdir -p $(OUT)
 	$(ARCHIVE) $@ $^
 	- $(RANLIB) $@
 
-$(OUT)/libscsdir.$(SHARED): $(SCS_OBJECTS) $(DIRSRC)/private.o $(AMD_OBJS) $(LDL_OBJS) $(LINSYS)/amatrix.o
+$(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)
 
-$(OUT)/libscsindir.$(SHARED): $(SCS_OBJECTS) $(INDIRSRC)/private.o $(LINSYS)/amatrix.o
+$(OUT)/libscsindir.$(SHARED): $(SCS_INDIR_O) $(SCS_OBJECTS) $(INDIRSRC)/private.o $(LINSYS)/scs_matrix.o $(LINSYS)/csparse.o
 	mkdir -p $(OUT)
 	$(CC) $(CFLAGS) -shared -Wl,$(SONAME),$(@:$(OUT)/%=%) -o $@ $^ $(LDFLAGS)
 
@@ -108,22 +115,22 @@ $(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_OBJECTS) $(GPUDIR)/private.o $(AMD_OBJS) $(LINSYS)/amatrix.o $(LINSYS)/gpu/gpu.o
+# $(OUT)/libscsgpudir.$(SHARED): $(SCS_O) $(SCS_OBJECTS) $(GPUDIR)/private.o $(AMD_OBJS) $(LINSYS)/scs_matrix.o $(LINSYS)/gpu/gpu.o
 #	 mkdir -p $(OUT)
 # 	$(CC) $(CFLAGS) -shared -Wl,$(SONAME),$(@:$(OUT)/%=%) -o $@ $^ $(LDFLAGS) $(CULDFLAGS)
 
-# $(OUT)/libscsgpudir.a: $(SCS_OBJECTS) $(GPUDIR)/private.o $(AMD_OBJS) $(LINSYS)/amatrix.o $(LINSYS)/gpu/gpu.o
+# $(OUT)/libscsgpudir.a: $(SCS_INDIR_O) $(SCS_OBJECTS) $(GPUDIR)/private.o $(AMD_OBJS) $(LINSYS)/scs_matrix.o $(LINSYS)/gpu/gpu.o
 #  	mkdir -p $(OUT)
 # 	$(ARCHIVE) $@ $^
 # 	- $(RANLIB) $@
 
-$(OUT)/libscsgpuindir.$(SHARED): $(SCS_OBJECTS) $(GPUINDIR)/private.o $(LINSYS)/amatrix.o $(LINSYS)/gpu/gpu.o
+$(OUT)/libscsgpuindir.$(SHARED): $(SCS_O) $(SCS_OBJECTS) $(GPUINDIR)/private.o $(LINSYS)/scs_matrix.o $(LINSYS)/csparse.o $(LINSYS)/gpu/gpu.o
 	mkdir -p $(OUT)
 	$(CC) $(CFLAGS) -shared -Wl,$(SONAME),$(@:$(OUT)/%=%) -o $@ $^ $(LDFLAGS) $(CULDFLAGS)
 
-$(OUT)/libscsgpuindir.a: $(SCS_OBJECTS) $(GPUINDIR)/private.o $(LINSYS)/amatrix.o $(LINSYS)/gpu/gpu.o
+$(OUT)/libscsgpuindir.a: $(SCS_INDIR_O) $(SCS_OBJECTS) $(GPUINDIR)/private.o $(LINSYS)/scs_matrix.o $(LINSYS)/csparse.o $(LINSYS)/gpu/gpu.o
 	mkdir -p $(OUT)
 	$(ARCHIVE) $@ $^
 	- $(RANLIB) $@
@@ -136,7 +143,7 @@ $(OUT)/demo_socp_gpu_indirect: test/random_socp_prob.c $(OUT)/libscsgpuindir.a
 
 .PHONY: clean purge
 clean:
-	@rm -rf $(TARGETS) $(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
@@ -153,7 +160,7 @@ INSTALL_GPU_TARGETS = $(OUT)/libscsgpuindir.a $(OUT)/libscsgpuindir.$(SHARED) #
 INSTALL_INC_DIR = $(DESTDIR)$(PREFIX)/include/scs/
 INSTALL_LIB_DIR = $(DESTDIR)$(PREFIX)/lib/
 
-.PHONY: install install_gpu
+.PHONY: install install_gpu direct indirect
 install: $(INSTALL_INC_FILES) $(INSTALL_TARGETS)
 	$(INSTALL) -d $(INSTALL_INC_DIR) $(INSTALL_LIB_DIR)
 	$(INSTALL) -m 644 $(INSTALL_INC_FILES) $(INSTALL_INC_DIR)
@@ -162,3 +169,5 @@ install_gpu: $(INSTALL_INC_FILES) $(INSTALL_GPU_TARGETS)
 	$(INSTALL) -d $(INSTALL_INC_DIR) $(INSTALL_LIB_DIR)
 	$(INSTALL) -m 644 $(INSTALL_INC_FILES) $(INSTALL_INC_DIR)
 	$(INSTALL) -m 644 $(INSTALL_GPU_TARGETS) $(INSTALL_LIB_DIR)
+direct:$(OUT)/libscsdir.$(SHARED) $(OUT)/demo_socp_direct $(OUT)/run_from_file_direct $(OUT)/run_tests_direct
+indirect:$(OUT)/libscsindir.$(SHARED) $(OUT)/demo_socp_indirect $(OUT)/run_from_file_indirect $(OUT)/run_tests_indirect

data/vendor/scs/README.md

@@ -1,222 +1,13 @@
-SCS
-====
+<h1 align="center" margin=0px>
+<img src="https://github.com/cvxgrp/scs/blob/master/docs/src/_static/scs_logo.png" alt="Intersection of a cone and a polyhedron" width="450">
+</h1>
 
-[![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)
+[![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, based on our paper [Conic Optimization via
-Operator Splitting and Homogeneous Self-Dual
-Embedding](http://www.stanford.edu/~boyd/papers/scs.html). It is written in C
-and can be used in other C, C++,
-[Python](https://github.com/bodono/scs-python),
-[Matlab](https://github.com/bodono/scs-matlab),
-[R](https://github.com/bodono/scs-r),
-[Julia](https://github.com/JuliaOpt/SCS.jl), and
-[Ruby](https://github.com/ankane/scs),
-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
-[Yalmip](https://github.com/johanlofberg/YALMIP).
-
-The current version is `2.1.2`. If you wish to cite SCS, please use the
-following:
-```
-@article{ocpb:16,
-    author       = {B. O'Donoghue and E. Chu and N. Parikh and S. Boyd},
-    title        = {Conic Optimization via Operator Splitting and Homogeneous Self-Dual Embedding},
-    journal      = {Journal of Optimization Theory and Applications},
-    month        = {June},
-    year         = {2016},
-    volume       = {169},
-    number       = {3},
-    pages        = {1042-1068},
-    url          = {http://stanford.edu/~boyd/papers/scs.html},
-}
-@misc{scs,
-    author       = {B. O'Donoghue and E. Chu and N. Parikh and S. Boyd},
-    title        = {{SCS}: Splitting Conic Solver, version 2.1.2},
-    howpublished = {\url{https://github.com/cvxgrp/scs}},
-    month        = nov,
-    year         = 2019
-}
-```
-
-----
-SCS numerically solves convex cone programs using the alternating direction
-method of multipliers
-([ADMM](http://web.stanford.edu/~boyd/papers/admm_distr_stats.html)).  It
-returns solutions to both the primal and dual problems if the problem is
-feasible, or a certificate of infeasibility otherwise. It solves the following
-primal cone problem:
-
-```
-minimize        c'x
-subject to      Ax + s = b
-                s in K
-```
-over variables `x` and `s`, where `A`, `b` and `c` are user-supplied data and
-`K` is a user-defined convex cone.  The dual problem is given by
-```
-maximize        -b'y
-subject to      -A'y == c
-                y in K^*
-```
-over variable `y`, where `K^*` denotes the dual cone to `K`.
-
-The cone `K` can be any Cartesian product of the following primitive cones:
-+ zero cone `{x | x = 0 }` (dual to the free cone `{x | x in R}`)
-+ positive orthant `{x | x >= 0}`
-+ second-order cone `{(t,x) | ||x||_2 <= t}`
-+ positive semidefinite cone `{ X | min(eig(X)) >= 0, X = X^T }`
-+ exponential cone `{(x,y,z) | y e^(x/y) <= z, y>0 }`
-+ dual exponential cone `{(u,v,w) | −u e^(v/u) <= e w, u<0}`
-+ power cone `{(x,y,z) | x^a * y^(1-a) >= |z|, x>=0, y>=0}`
-+ dual power cone `{(u,v,w) | (u/a)^a * (v/(1-a))^(1-a) >= |w|, u>=0, v>=0}`
-
-The rows of the data matrix `A` correspond to the cones in `K`.  **The rows of
-`A` must be in the order of the cones given above, i.e., first come the rows
-that correspond to the zero/free cones, then those that correspond to the
-positive orthants, then SOCs, etc.** For a `k` dimensional semidefinite cone
-when interpreting the rows of the data matrix `A` SCS assumes that the `k x k`
-matrix variable has been vectorized by scaling the off-diagonal entries by
-`sqrt(2)` and stacking the **lower triangular elements column-wise** to create a
-vector of length `k(k+1)/2`. See the section on semidefinite programming below.
-
-At termination SCS returns solution `(x*, s*, y*)` if the problem is feasible,
-or a certificate of infeasibility otherwise. See
-[here](http://web.stanford.edu/~boyd/cvxbook/) for more details about
-cone programming and certificates of infeasibility.
-
-**Anderson Acceleration**
-
-By default SCS uses Anderson acceleration (AA) to speed up convergence. The
-number of iterates that SCS uses in the AA calculation can be controlled by the
-parameter `acceleration_lookback` in the settings struct. It defaults to 10.  AA
-is available as a standalone package [here](https://github.com/cvxgrp/aa).  More
-details are available in our paper on AA
-[here](https://stanford.edu/~boyd/papers/nonexp_global_aa1.html).
-
-**Semidefinite Programming**
-
-SCS assumes that the matrix variables and the input data corresponding to
-semidefinite cones have been vectorized by **scaling the off-diagonal entries by
-`sqrt(2)`** and stacking the lower triangular elements **column-wise**. For a `k
-x k` matrix variable (or data matrix) this operation would create a vector of
-length `k(k+1)/2`. Scaling by `sqrt(2)` is required to preserve the
-inner-product.
-
-**To recover the matrix solution this operation must be inverted on the
-components of the vector returned by SCS corresponding to semidefinite cones**.
-That is, the off-diagonal entries must be scaled by `1/sqrt(2)` and the upper
-triangular entries are filled in by copying the values of lower triangular
-entries.
-
-More explicitly, we want to express
-`Tr(C X)` as `vec(C)'*vec(X)`, where the `vec` operation takes the `k x k` matrix
-```
-X = [ X11 X12 ... X1k
-      X21 X22 ... X2k
-      ...
-      Xk1 Xk2 ... Xkk ]
-```
-and produces a vector consisting of
-```
-vec(X) = (X11, sqrt(2)*X21, ..., sqrt(2)*Xk1, X22, sqrt(2)*X32, ..., Xkk).
-```
-
-**Linear equation solvers**
-
-Each iteration of SCS requires the solution of a set of linear equations.  This
-package includes two implementations for solving linear equations: a direct
-solver which uses a cached LDL factorization and an indirect solver based on
-conjugate gradients. The indirect solver can be run on either the cpu or
-gpu.
-
-The direct solver uses external numerical linear algebra packages:
-* [QDLDL](https://github.com/oxfordcontrol/qdldl)
-* [AMD](http://www.cise.ufl.edu/research/sparse/).
-
-### Using SCS in C
-Typing `make` at the command line will compile the code and create SCS libraries
-in the `out` folder. To run the tests execute:
-```sh
-make
-make test
-test/run_tests
-```
-
-If `make` completes successfully, it will produce two static library files,
-`libscsdir.a`, `libscsindir.a`, and two dynamic library files `libscsdir.ext`,
-`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
-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`.
 
-To use the libraries in your own source code, compile your code with the linker
-option `-L(PATH_TO_SCS_LIBS)` and `-lscsdir` or `-lscsindir` (as needed).  The
-API and required data structures are defined in the file `include/scs.h`.  The
-four main API functions are:
-
-* `ScsWork * scs_init(const ScsData * d, const ScsCone * k, ScsInfo * info);`
-
-    This initializes the ScsWork struct containing the workspace that scs will
-    use, and performs the necessary preprocessing (e.g. matrix factorization).
-    All inputs `d`, `k`, and `info` must be memory allocated before calling.
-
-* `scs_int scs_solve(ScsWork * w, const ScsData * d, const ScsCone * k, ScsSolution * sol, ScsInfo * info);`
-
-    This solves the problem as defined by ScsData `d` and ScsCone `k` using the
-    workspace in `w`. The solution is returned in `sol` and information about
-    the solve is returned in `info` (outputs must have memory allocated before
-    calling).  None of the inputs can be NULL. You can call `scs_solve` many
-    times for one call to `scs_init`, so long as the matrix `A` does not change
-    (vectors `b` and `c` can change).
-
-* `void scs_finish(ScsWork * w);`
-
-    Called after all solves completed to free allocated memory and other
-    cleanup.
-
-* `scs_int scs(const ScsData * d, const ScsCone * k, ScsSolution * sol, ScsInfo * info);`
-
-    Convenience method that simply calls all the above routines in order, for
-    cases where the workspace does not need to be reused. All inputs must have
-    memory allocated before this call.
-
-The data matrix `A` is specified in column-compressed format and the vectors `b`
-and `c` are specified as dense arrays. The solutions `x` (primal), `s` (slack),
-and `y` (dual) are returned as dense arrays. Cones are specified as the struct
-defined in `include/scs.h`, the rows of `A` must correspond to the cones in the
-exact order as specified by the cone struct (i.e. put linear cones before
-second-order cones etc.).
-
-**Warm-start**
-
-You can warm-start SCS (supply a guess of the solution) by setting `warm_start`
-in the ScsData struct to `1` and supplying the warm-starts in the ScsSolution
-struct (`x`,`y`, and `s`). All inputs must be warm-started if any one is. These
-are used to initialize the iterates in `scs_solve`.
-
-**Re-using matrix factorization**
-
-If using the direct version you can factorize the matrix once and solve many
-times. Simply call `scs_init` once, and use `scs_solve` many times with the same
-workspace, changing the input data `b` and `c` (and optionally warm-starts) for
-each iteration.
-
-**Using your own linear system solver**
-
-To use your own linear system solver simply implement all the methods and the
-two structs in `include/linsys.h` and plug it in.
-
-**BLAS / LAPACK install error**
+SCS (`splitting conic solver`) is a numerical optimization package for solving
+large-scale convex cone problems. The current version is `3.1.1`.
 
-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.
+The full documentation is available [here](https://www.cvxgrp.org/scs/).