scs 0.5.6 → 0.6.0

data/vendor/scs/CMakeLists.txt

@@ -1,24 +1,24 @@
 # 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)
+# 3.22: FindLAPACK honors BLA_SIZEOF_INTEGER (the LP64/ILP64 contract) and
+# provides the LAPACK::LAPACK target that keeps static packages relocatable.
+cmake_minimum_required(VERSION 3.22)
 
 project(
   scs
   LANGUAGES C
-  VERSION 3.2.11)
+  VERSION 3.3.1)
 
-# Defines the CMAKE_INSTALL_LIBDIR, CMAKE_INSTALL_BINDIR and many other useful
-# macros. See https://cmake.org/cmake/help/latest/module/GNUInstallDirs.html
+# ABI version, the loader identity of the shared libraries (libscsdir.so.3.3):
+# bump on ABI breaks, never on patch releases. scs.mk derives the same value
+# from SCS_VERSION in include/glbopts.h.
+set(SCS_ABI_VERSION "${scs_VERSION_MAJOR}.${scs_VERSION_MINOR}")
+
+# Standard GNU install directories (lib, bin, include, etc.)
 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.
+# Place executables in bin/ and libraries in lib/ within the build tree.
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY
     "${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_BINDIR}")
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY
@@ -26,45 +26,34 @@ set(CMAKE_LIBRARY_OUTPUT_DIRECTORY
 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/
+# Export all symbols on Windows (avoids __declspec(dllexport) annotations).
 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.
+# Append "d" suffix to debug libraries under MSVC to avoid name clashes.
 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/
+# Position-independent code is required for 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.
+# Disable compiler extensions for strict standard compliance.
+# Strict C99, the oldest standard a shipping consumer compiles scs with (the
+# MATLAB binding uses -std=c99): GNU-only constructs fail here first.
+set(CMAKE_C_STANDARD 99)
+set(CMAKE_C_STANDARD_REQUIRED ON)
 set(CMAKE_C_EXTENSIONS OFF)
+# Strict C99 hides POSIX declarations on glibc and illumos (sigaction,
+# clock_gettime, struct timespec) unless a feature-test macro asks for them.
+# A compile definition reaches every translation unit whatever its include
+# order, which a header cannot guarantee.
+if(CMAKE_SYSTEM_NAME MATCHES "Linux|SunOS")
+  add_compile_definitions(_POSIX_C_SOURCE=200809L)
+endif()
+
 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
@@ -78,8 +67,7 @@ add_install_rpath_support(
   "${CMAKE_INSTALL_FULL_LIBDIR}"
   USE_LINK_PATH)
 
-# Encourage user to specify a build type (e.g. Release, Debug, etc.), otherwise
-# set it to Release.
+# Default to Release build type if none specified.
 if(NOT CMAKE_CONFIGURATION_TYPES)
   if(NOT CMAKE_BUILD_TYPE)
     message(STATUS "Setting build type to 'Release' as none was specified.")
@@ -87,115 +75,187 @@ if(NOT CMAKE_CONFIGURATION_TYPES)
   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.
+# Support 'make uninstall' after install.
 include(AddUninstallTarget)
 
-# Some variables useful for sampling the building process. Note that the GPU
-# profile is not compiled.
+# Linear system solver directories.
 set(LINSYS linsys)
 set(DIRSRC ${LINSYS}/cpu/direct)
 set(INDIRSRC ${LINSYS}/cpu/indirect)
 set(EXTERNAL ${LINSYS}/external)
 
-# Options
-# ----------------------------------------------
-# Use floats instead of doubles
+# Build options
 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}")
 
-# Disable all printing
 option(NO_PRINTING "Disables all printing" OFF)
 message(STATUS "Printing is NOT ${NO_PRINTING}")
 
-# Disable all read/write functionality
 option(NO_READ_WRITE "Disables all read/write functionality" OFF)
 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(BLAS64 "Use 64-bit integers for BLAS/LAPACK" OFF)
+message(STATUS "64-bit BLAS integers are ${BLAS64}")
+
 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")
+if(APPLE)
+  option(USE_APPLE_ACCELERATE "Use Apple Accelerate framework for sparse LDLt" OFF)
+  message(STATUS "Apple Accelerate support is ${USE_APPLE_ACCELERATE}")
+endif()
+
+set(COMPILER_OPTS CTRLC)
 set(LAPACK_LINK_LIBRARIES "")
+set(SCS_TEST_LINK_LIBRARIES "")
+if(NOT WIN32)
+  list(APPEND SCS_TEST_LINK_LIBRARIES m)
+endif()
 
 # Primitive types
 if(SFLOAT)
   set(SCS_FLOAT_TYPE "float")
-  set(COMPILER_OPTS "-DSFLOAT ${COMPILER_OPTS}")
+  list(APPEND COMPILER_OPTS SFLOAT)
 else()
   set(SCS_FLOAT_TYPE "double")
 endif()
 
 if(DLONG)
   set(SCS_INT_TYPE "long long")
-  set(COMPILER_OPTS "-DDLONG ${COMPILER_OPTS}")
+  list(APPEND COMPILER_OPTS DLONG)
 else()
   set(SCS_INT_TYPE "int")
 endif()
 
 if(NO_PRINTING)
-  set(COMPILER_OPTS "-DNO_PRINTING=1 ${COMPILER_OPTS}")
+  list(APPEND COMPILER_OPTS NO_PRINTING=1)
 endif()
 
 if(NO_READ_WRITE)
-  set(COMPILER_OPTS "-DNO_READ_WRITE=1 ${COMPILER_OPTS}")
+  list(APPEND COMPILER_OPTS NO_READ_WRITE=1)
 endif()
 
 if(USE_LAPACK)
-  set(COMPILER_OPTS "-DUSE_LAPACK ${COMPILER_OPTS}")
-  list(APPEND LAPACK_LINK_LIBRARIES "blas" "lapack")
+  list(APPEND COMPILER_OPTS USE_LAPACK)
+  if(BLAS64)
+    list(APPEND COMPILER_OPTS BLAS64)
+    set(BLA_SIZEOF_INTEGER 8)
+  else()
+    set(BLA_SIZEOF_INTEGER 4)
+  endif()
+  if(DEFINED ENV{MKLROOT} AND NOT DEFINED BLA_VENDOR)
+    if(BLAS64)
+      set(BLA_VENDOR Intel10_64ilp)
+    else()
+      set(BLA_VENDOR Intel10_64lp)
+    endif()
+  endif()
+  find_package(LAPACK)
+  if(LAPACK_FOUND)
+    # Link the imported target, not resolved paths: a static library exports
+    # its private link line, and absolute provider paths would make the
+    # installed package usable only on this machine.
+    set(LAPACK_LINK_LIBRARIES LAPACK::LAPACK)
+  else()
+    if(BLAS64)
+      message(FATAL_ERROR
+              "BLAS64=ON requires a discoverable ILP64 BLAS/LAPACK library. "
+              "CMake did not find one. Set BLA_VENDOR explicitly or configure "
+              "with -DBLAS64=OFF.")
+    endif()
+    # Fallback to linking by name (works on most Linux/Mac systems).
+    set(LAPACK_LINK_LIBRARIES blas lapack)
+  endif()
 endif()
 
+find_package(Threads REQUIRED)
+
 if(USE_OPENMP)
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fopenmp")
+  find_package(OpenMP)
+  if(OpenMP_C_FOUND)
+    # Link target used below via target_link_libraries.
+  else()
+    message(WARNING "OpenMP requested but not found by CMake")
+  endif()
 endif()
 
-# Flags for spectral cones.
 if(USE_SPECTRAL_CONES)
-  set(COMPILER_OPTS "-DUSE_SPECTRAL_CONES ${COMPILER_OPTS}")
+  list(APPEND COMPILER_OPTS USE_SPECTRAL_CONES)
 endif()
 
+option(USE_SPECTRAL_TIMING_FLAG "Enable timing of spectral cone projections" OFF)
 if(USE_SPECTRAL_TIMING_FLAG)
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DSPECTRAL_TIMING_FLAG")
+  list(APPEND COMPILER_OPTS SPECTRAL_TIMING_FLAG)
 endif()
 
+option(USE_SPECTRAL_DEBUG "Enable spectral cone debug output" OFF)
 if(USE_SPECTRAL_DEBUG)
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DSPECTRAL_DEBUG")
+  list(APPEND COMPILER_OPTS SPECTRAL_DEBUG)
 endif()
 
 message(STATUS "COMPILER_OPTS = ${COMPILER_OPTS}")
 message(STATUS "CMAKE_C_FLAGS = ${CMAKE_C_FLAGS}")
 
-# 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.
+# Generate a build-tree include overlay so CMake configuration never modifies
+# the checked-in Make-compatible headers.
+set(SCS_BUILD_INCLUDE_DIR "${CMAKE_CURRENT_BINARY_DIR}/include")
+set(SCS_GENERATED_TYPES_HDR "${SCS_BUILD_INCLUDE_DIR}/scs_types.h")
+file(MAKE_DIRECTORY "${SCS_BUILD_INCLUDE_DIR}")
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/scs_types.h.in
-               ${CMAKE_CURRENT_SOURCE_DIR}/include/scs_types.h NEWLINE_STYLE LF)
+               ${SCS_GENERATED_TYPES_HDR} NEWLINE_STYLE LF)
+
+set(SCS_CONFIGURED_INCLUDE_HDR
+    include/aa.h
+    include/aa_stats.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_work.h
+    include/util.h
+    include/util_spectral_cones.h)
+
+set(SCS_BUILD_INCLUDE_HDR "")
+foreach(_scs_header ${SCS_CONFIGURED_INCLUDE_HDR})
+  get_filename_component(_scs_header_name "${_scs_header}" NAME)
+  set(_scs_build_header "${SCS_BUILD_INCLUDE_DIR}/${_scs_header_name}")
+  configure_file("${CMAKE_CURRENT_SOURCE_DIR}/${_scs_header}"
+                 "${_scs_build_header}" COPYONLY)
+  list(APPEND SCS_BUILD_INCLUDE_HDR "${_scs_build_header}")
+endforeach()
 
 # Public headers
-set(${PROJECT_NAME}_PUBLIC_HDR include/scs_types.h include/scs.h)
+set(${PROJECT_NAME}_PUBLIC_HDR
+    "${SCS_BUILD_INCLUDE_DIR}/aa_stats.h"
+    "${SCS_GENERATED_TYPES_HDR}"
+    "${SCS_BUILD_INCLUDE_DIR}/scs.h")
+set(SCS_PUBLIC_INCLUDE_DIRS
+    "$<BUILD_INTERFACE:${SCS_BUILD_INCLUDE_DIR}>"
+    "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/scs>")
 
 # Common source files
 set(${PROJECT_NAME}_SRC
@@ -231,40 +291,24 @@ endif()
 
 # 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
+    ${SCS_BUILD_INCLUDE_HDR}
+    ${SCS_GENERATED_TYPES_HDR}
     ${LINSYS}/csparse.h
     ${LINSYS}/scs_matrix.h)
 
 # Spectral header files
-set(SPECTRAL_HDR include/util_spectral_cones.h)
+set(SPECTRAL_HDR "${SCS_BUILD_INCLUDE_DIR}/util_spectral_cones.h")
 
 if(USE_SPECTRAL_CONES)
   list(APPEND ${PROJECT_NAME}_HDR ${SPECTRAL_HDR})
 endif()
 
-# get all the c file in amd/external
+# External vendored dependencies (AMD ordering, QDLDL factorization).
 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.
+# Direct method library.
 set(${PROJECT_NAME}_DIRECT ${PROJECT_NAME}dir)
 add_library(
   ${${PROJECT_NAME}_DIRECT}
@@ -285,25 +329,24 @@ target_include_directories(
 
 target_include_directories(
   ${${PROJECT_NAME}_DIRECT}
-  PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
-         "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/scs>")
+  PUBLIC ${SCS_PUBLIC_INCLUDE_DIRS})
 
-# 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) and (optionally) blas and lapack
 target_link_libraries(${${PROJECT_NAME}_DIRECT}
-                      PRIVATE m ${LAPACK_LINK_LIBRARIES})
+                      PRIVATE ${LAPACK_LINK_LIBRARIES}
+                              $<$<NOT:$<PLATFORM_ID:Windows>>:m>
+                              $<$<BOOL:${OpenMP_C_FOUND}>:OpenMP::OpenMP_C>
+                              Threads::Threads)
 
-# Set some properties
 set_target_properties(
   ${${PROJECT_NAME}_DIRECT}
-  PROPERTIES VERSION ${scs_VERSION} PUBLIC_HEADER
+  PROPERTIES VERSION ${scs_VERSION} SOVERSION ${SCS_ABI_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}
@@ -313,12 +356,9 @@ install(
   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.
+# Indirect method library.
 set(${PROJECT_NAME}_INDIRECT ${PROJECT_NAME}indir)
 add_library(
   ${${PROJECT_NAME}_INDIRECT}
@@ -333,26 +373,25 @@ target_include_directories(
 
 target_include_directories(
   ${${PROJECT_NAME}_INDIRECT}
-  PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
-         "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/scs>")
+  PUBLIC ${SCS_PUBLIC_INCLUDE_DIRS})
 
-# 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) and (optionally) blas and lapack
 target_link_libraries(${${PROJECT_NAME}_INDIRECT}
-                      PUBLIC m ${LAPACK_LINK_LIBRARIES})
+                      PRIVATE $<$<NOT:$<PLATFORM_ID:Windows>>:m>
+                              ${LAPACK_LINK_LIBRARIES}
+                              $<$<BOOL:${OpenMP_C_FOUND}>:OpenMP::OpenMP_C>
+                              Threads::Threads)
 
-# Set some properties
 set_target_properties(
   ${${PROJECT_NAME}_INDIRECT}
-  PROPERTIES VERSION ${scs_VERSION} PUBLIC_HEADER
+  PROPERTIES VERSION ${scs_VERSION} SOVERSION ${SCS_ABI_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}
@@ -362,20 +401,71 @@ install(
   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})
 
-# ##############################################################################
+# Dense direct method library (optional, requires LAPACK).
+if(USE_LAPACK)
+  set(DENSESRC ${LINSYS}/cpu/dense)
+
+  set(${PROJECT_NAME}_DENSE ${PROJECT_NAME}dense)
+  add_library(
+    ${${PROJECT_NAME}_DENSE}
+    ${${PROJECT_NAME}_HDR} ${${PROJECT_NAME}_SRC} ${DENSESRC}/private.c
+    ${DENSESRC}/private.h)
+
+  target_include_directories(
+    ${${PROJECT_NAME}_DENSE}
+    PRIVATE
+      "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/${DENSESRC};${CMAKE_CURRENT_SOURCE_DIR}/${LINSYS}>"
+  )
+
+  target_include_directories(
+    ${${PROJECT_NAME}_DENSE}
+    PUBLIC ${SCS_PUBLIC_INCLUDE_DIRS})
+
+  target_compile_definitions(${${PROJECT_NAME}_DENSE} PRIVATE ${COMPILER_OPTS})
+
+  target_link_libraries(${${PROJECT_NAME}_DENSE}
+                        PRIVATE ${LAPACK_LINK_LIBRARIES}
+                                $<$<NOT:$<PLATFORM_ID:Windows>>:m>
+                                $<$<BOOL:${OpenMP_C_FOUND}>:OpenMP::OpenMP_C>
+                                Threads::Threads)
+
+  set_target_properties(
+    ${${PROJECT_NAME}_DENSE}
+    PROPERTIES VERSION ${scs_VERSION} SOVERSION ${SCS_ABI_VERSION}
+             PUBLIC_HEADER
+                                      "${${PROJECT_NAME}_PUBLIC_HDR}")
+
+  add_library(scs::${${PROJECT_NAME}_DENSE} ALIAS ${${PROJECT_NAME}_DENSE})
+
+  install(
+    TARGETS ${${PROJECT_NAME}_DENSE}
+    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")
+
+  set_property(GLOBAL APPEND PROPERTY SCS_TARGETS ${${PROJECT_NAME}_DENSE})
+endif()
 
-# If MKLROOT is defined, then we install the MKL version.
+# MKL Pardiso library (optional, requires MKLROOT environment variable).
 if(DEFINED ENV{MKLROOT})
 
   message(STATUS "MKLROOT set to $ENV{MKLROOT}")
   message(STATUS "Will install SCS-MKL (libscsmkl).")
 
+  if(BLAS64 AND NOT DLONG)
+    message(FATAL_ERROR
+            "MKL PARDISO with BLAS64 requires DLONG=ON so that the "
+            "pardiso_64 entry point matches the ILP64 BLAS interface.")
+  endif()
+
   set(MKLSRC ${LINSYS}/mkl/direct)
 
-  # Here we compile the direct MKL pardiso library
+  # MKL Pardiso direct solver library
   set(${PROJECT_NAME}_MKL ${PROJECT_NAME}mkl)
   add_library(
     ${${PROJECT_NAME}_MKL}
@@ -390,35 +480,41 @@ if(DEFINED ENV{MKLROOT})
 
   target_include_directories(
     ${${PROJECT_NAME}_MKL}
-    PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
-           "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/scs>")
-
-  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.
-  target_link_options(${${PROJECT_NAME}_MKL} PRIVATE "LINKER:--no-as-needed")
-  target_link_directories(${${PROJECT_NAME}_MKL} PRIVATE $ENV{MKLROOT}/lib)
+    PUBLIC ${SCS_PUBLIC_INCLUDE_DIRS})
+
+  target_compile_definitions(
+    ${${PROJECT_NAME}_MKL}
+    PRIVATE ${COMPILER_OPTS} SCS_MKL)
+  # Link against mkl_rt (the single dynamic library) which dispatches to the
+  # correct interface layer at runtime. The BLAS integer width (LP64 vs ILP64)
+  # is set at startup by the MKL-specific path in src/scs.c, controlled by the
+  # BLAS64 compile flag.
+  #
+  # Note: The PARDISO integer width (pardiso vs pardiso_64) is controlled by
+  # DLONG, not by the MKL interface layer. See linsys/mkl/direct/private.c.
+  # oneMKL's own package config (MKLConfig.cmake, oneMKL >= 2021.3) provides
+  # the MKL::MKL target, which keeps a static export relocatable; SDL mode
+  # links the single dynamic library (mkl_rt) whose MKL_Set_Interface_Layer
+  # the runtime check uses. --no-as-needed keeps mkl_rt as DT_NEEDED for that
+  # check; it is a GNU/ELF option, hence Linux only.
+  set(MKL_LINK sdl)
+  find_package(MKL CONFIG REQUIRED PATHS "$ENV{MKLROOT}")
+  set(SCS_MKL_USES_CONFIG TRUE)
+  target_link_options(${${PROJECT_NAME}_MKL} PRIVATE
+                      "$<$<PLATFORM_ID:Linux>:LINKER:--no-as-needed>")
   target_link_libraries(
     ${${PROJECT_NAME}_MKL}
-    PRIVATE m
-            mkl_rt
-            mkl_gnu_thread
-            mkl_core
-            gomp
-            pthread
-            dl)
-
-  # Set some properties
+    PRIVATE $<$<NOT:$<PLATFORM_ID:Windows>>:m> MKL::MKL Threads::Threads
+            ${CMAKE_DL_LIBS})
+
   set_target_properties(
     ${${PROJECT_NAME}_MKL}
-    PROPERTIES VERSION ${scs_VERSION} PUBLIC_HEADER
+    PROPERTIES VERSION ${scs_VERSION} SOVERSION ${SCS_ABI_VERSION}
+             PUBLIC_HEADER
                                       "${${PROJECT_NAME}_PUBLIC_HDR}")
 
   add_library(scs::${${PROJECT_NAME}_MKL} ALIAS ${${PROJECT_NAME}_MKL})
 
-  # Install the library
   install(
     TARGETS ${${PROJECT_NAME}_MKL}
     EXPORT ${PROJECT_NAME}
@@ -428,7 +524,6 @@ if(DEFINED ENV{MKLROOT})
     RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}" COMPONENT bin
     PUBLIC_HEADER DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/scs")
 
-  # Add the mkl method to the set of the compiled targets
   set_property(GLOBAL APPEND PROPERTY SCS_TARGETS ${${PROJECT_NAME}_MKL})
 else()
   message(
@@ -436,10 +531,7 @@ else()
   )
 endif()
 
-# ##############################################################################
-
-# If cuDSS is enabled and environment variables are set, install the cuDSS
-# version
+# cuDSS GPU solver library (optional, requires CUDA toolkit and cuDSS).
 if(USE_CUDSS)
   find_package(CUDAToolkit REQUIRED)
   find_package(cudss REQUIRED)
@@ -456,7 +548,6 @@ if(USE_CUDSS)
 
   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}
@@ -470,25 +561,24 @@ if(USE_CUDSS)
 
   target_include_directories(
     ${${PROJECT_NAME}_CUDSS}
-    PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
-           "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/scs>")
+    PUBLIC ${SCS_PUBLIC_INCLUDE_DIRS})
 
   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})
+            ${LAPACK_LINK_LIBRARIES}
+            Threads::Threads)
 
-  # Set some properties
   set_target_properties(
     ${${PROJECT_NAME}_CUDSS}
-    PROPERTIES VERSION ${scs_VERSION} PUBLIC_HEADER
+    PROPERTIES VERSION ${scs_VERSION} SOVERSION ${SCS_ABI_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}
@@ -498,13 +588,75 @@ if(USE_CUDSS)
     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.
+# Apple Accelerate library (optional, macOS only).
+if(APPLE AND USE_APPLE_ACCELERATE)
+  if(DLONG)
+    message(
+      FATAL_ERROR
+        "Apple Accelerate requires 32-bit integers. Set DLONG=OFF or do not use -DDLONG=ON"
+    )
+  endif()
+
+  message(STATUS "Will install SCS-Accelerate (libscsaccel).")
+
+  set(ACCELSRC ${LINSYS}/accelerate/direct)
+
+  set(${PROJECT_NAME}_ACCEL ${PROJECT_NAME}accel)
+  add_library(
+    ${${PROJECT_NAME}_ACCEL}
+    ${${PROJECT_NAME}_HDR} ${${PROJECT_NAME}_SRC} ${ACCELSRC}/private.c
+    ${ACCELSRC}/private.h)
+
+  target_include_directories(
+    ${${PROJECT_NAME}_ACCEL}
+    PRIVATE
+      "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/${ACCELSRC};${CMAKE_CURRENT_SOURCE_DIR}/${LINSYS}>"
+  )
+
+  target_include_directories(
+    ${${PROJECT_NAME}_ACCEL}
+    PUBLIC ${SCS_PUBLIC_INCLUDE_DIRS})
+
+  target_compile_definitions(${${PROJECT_NAME}_ACCEL} PRIVATE ${COMPILER_OPTS})
+
+  find_library(ACCELERATE_FRAMEWORK Accelerate REQUIRED)
+  target_link_libraries(
+    ${${PROJECT_NAME}_ACCEL}
+    PRIVATE ${ACCELERATE_FRAMEWORK}
+            $<$<BOOL:${OpenMP_C_FOUND}>:OpenMP::OpenMP_C>
+            Threads::Threads)
+
+  set_target_properties(
+    ${${PROJECT_NAME}_ACCEL}
+    PROPERTIES VERSION ${scs_VERSION} SOVERSION ${SCS_ABI_VERSION}
+             PUBLIC_HEADER
+                                      "${${PROJECT_NAME}_PUBLIC_HDR}")
+
+  add_library(scs::${${PROJECT_NAME}_ACCEL} ALIAS ${${PROJECT_NAME}_ACCEL})
+
+  install(
+    TARGETS ${${PROJECT_NAME}_ACCEL}
+    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")
+
+  set_property(GLOBAL APPEND PROPERTY SCS_TARGETS ${${PROJECT_NAME}_ACCEL})
+endif()
+
+# Install CMake package config files for find_package(scs) support.
 include(InstallBasicPackageFiles)
+# The config template re-finds a static library's private dependencies at the
+# LAPACK integer width scs was built with; see cmake/scsConfig.cmake.in.
+set(SCS_LAPACK_INT_BYTES "")
+if(USE_LAPACK AND LAPACK_FOUND)
+  set(SCS_LAPACK_INT_BYTES "${BLA_SIZEOF_INTEGER}")
+endif()
 install_basic_package_files(
   ${PROJECT_NAME}
   NAMESPACE
@@ -517,68 +669,45 @@ install_basic_package_files(
   SameMajorVersion
   VARS_PREFIX
   ${PROJECT_NAME}
+  CONFIG_TEMPLATE
+  "${CMAKE_CURRENT_SOURCE_DIR}/cmake/scsConfig.cmake.in"
   NO_CHECK_REQUIRED_COMPONENTS_MACRO)
 
-# Add the tests
+# 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})
-
-  if(DEFINED ENV{MKLROOT})
-    add_executable(run_tests_mkl test/run_tests.c)
-    target_compile_definitions(run_tests_mkl PRIVATE ${COMPILER_OPTS})
-    target_link_libraries(run_tests_mkl PRIVATE scs::scsmkl)
+  # Helper to avoid repeating test boilerplate for each backend.
+  function(scs_add_test TEST_NAME LINK_TARGET)
+    add_executable(${TEST_NAME} test/run_tests.c)
+    target_compile_definitions(${TEST_NAME} PRIVATE ${COMPILER_OPTS})
+    target_link_libraries(${TEST_NAME} PRIVATE ${LINK_TARGET}
+                                               ${SCS_TEST_LINK_LIBRARIES})
     target_include_directories(
-      run_tests_mkl
+      ${TEST_NAME}
       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;${SCS_BUILD_INCLUDE_DIR};${CMAKE_CURRENT_SOURCE_DIR}/${LINSYS}>"
     )
-
     add_test(
-      NAME run_tests_mkl
-      COMMAND run_tests_mkl
+      NAME ${TEST_NAME}
+      COMMAND ${TEST_NAME}
       WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+  endfunction()
+
+  scs_add_test(run_tests_direct scs::scsdir)
+  scs_add_test(run_tests_indirect scs::scsindir)
+
+  if(USE_LAPACK)
+    scs_add_test(run_tests_dense scs::scsdense)
   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}>"
-    )
+  if(DEFINED ENV{MKLROOT})
+    scs_add_test(run_tests_mkl scs::scsmkl)
+  endif()
 
-    add_test(
-      NAME run_tests_cudss
-      COMMAND run_tests_cudss
-      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+  if(USE_CUDSS)
+    scs_add_test(run_tests_cudss scs::scscudss)
   endif()
 
+  if(APPLE AND USE_APPLE_ACCELERATE)
+    scs_add_test(run_tests_accelerate scs::scsaccel)
+  endif()
 endif()