scs 0.5.5 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8ff5e9f042f1fd5244d1b1bc59c6308c8f70586b473d38272157fcbe05463aeb
-  data.tar.gz: 0ebb6044270c3eaa020c9965d08f51b35591f74e83594c756e901274eb001bf8
+  metadata.gz: ec3e1c1e0a72a5f66811dee0e533de60349c2f2c7fdda5a97041e729a3a50e6c
+  data.tar.gz: a71c167273d92064b8b24828bc78c6f62fda6a3b3b5c8b04fd5beeba0262a2d9
 SHA512:
-  metadata.gz: 4794fed3a60f87162b82a45d1acf90ca5008b29e87325bf3de074dc99b1100c130e03516d83b13655caa1cc43dd00cb91d19fc454ed463a1f29ce06e3d195038
-  data.tar.gz: 0e501a4181f3263fae54d4d98ab8b94284978cd94ccbf2c23b8d02699f35e63855011098fe2d580d5c1492cd61605a5914ef53b4c59456283f726cd28df13e3d
+  metadata.gz: 77fdb9295bf706e2730ac438d4ed570a012430878e26c72e0832da0453734ed1bf5aba09f9c1238094f914bc6dcc6551c5ef73197371b92d0dd4d2cf37e9f204
+  data.tar.gz: 76b6070b6898235cf070ab65598eb619e9a323f037df4dba4f4504232fd03c86d44a7783de1e0c5d760f69ae38093b1a1ce31212194c60b5d60f33d29b6afab9

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 0.6.0 (2026-09-05)
+
+- Updated SCS to 3.3.1
+- Dropped support for Ruby < 3.3
+
+## 0.5.6 (2026-02-27)
+
+- Fixed memory leak in `solve` method
+
 ## 0.5.5 (2026-01-11)
 
 - Updated SCS to 3.2.11

data/LICENSE.txt

@@ -1,7 +1,7 @@
 The MIT License (MIT)
 
 Copyright (c) 2012 Brendan O'Donoghue (bodonoghue85@gmail.com)
-Copyright (c) 2019-2025 Andrew Kane
+Copyright (c) 2019-2026 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

data/lib/scs/ffi.rb

@@ -63,6 +63,19 @@ module SCS
           "scs_float *s"
         ]
 
+        m::AaStats = struct [
+          "scs_int iter",
+          "scs_int n_accept",
+          "scs_int n_reject_lapack",
+          "scs_int n_reject_rank0",
+          "scs_int n_reject_nonfinite",
+          "scs_int n_reject_weight_cap",
+          "scs_int n_safeguard_reject",
+          "scs_int last_rank",
+          "scs_float last_aa_norm",
+          "scs_float last_regularization"
+        ]
+
         m::Info = struct [
           "scs_int iter",
           "char status[128]",
@@ -81,6 +94,7 @@ module SCS
           "scs_float solve_time",
           "scs_float scale",
           "scs_float comp_slack",
+          {aa_stats: m::AaStats},
           "scs_int rejected_accel_steps",
           "scs_int accepted_accel_steps",
           "scs_float lin_sys_time",
@@ -92,6 +106,7 @@ module SCS
           "scs_int normalize",
           "scs_float scale",
           "scs_int adaptive_scale",
+          "scs_int adaptive_diag_scale",
           "scs_float rho_x",
           "scs_int max_iters",
           "scs_float eps_abs",
@@ -103,6 +118,9 @@ module SCS
           "scs_int warm_start",
           "scs_int acceleration_lookback",
           "scs_int acceleration_interval",
+          "scs_int acceleration_type_1",
+          "scs_float acceleration_regularization",
+          "scs_float acceleration_relaxation",
           "const char* write_data_filename",
           "const char *log_csv_filename"
         ]

data/lib/scs/solver.rb

@@ -10,12 +10,21 @@ module SCS
       settings = create_settings(settings)
       ccone = create_cone(cone)
 
-      solution = calloc(ffi::Solution.size) # alloc clear memory
+      # alloc pointers and hold refs
+      solution_ptr = Fiddle::Pointer["\x00" * ffi::Solution.size] # alloc clear memory
+      x_ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_DOUBLE * cdata.n, Fiddle::RUBY_FREE)
+      y_ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_DOUBLE * cdata.m, Fiddle::RUBY_FREE)
+      s_ptr = Fiddle::Pointer.malloc(Fiddle::SIZEOF_DOUBLE * cdata.m, Fiddle::RUBY_FREE)
+
+      solution = ffi::Solution.new(solution_ptr)
+      solution.x = x_ptr
+      solution.y = y_ptr
+      solution.s = s_ptr
+
       info = ffi::Info.malloc(Fiddle::RUBY_FREE)
 
       ffi.scs(cdata, ccone, settings, solution, info)
 
-      solution = ffi::Solution.new(solution)
       x = read_float_array(solution.x, cdata.n)
       y = read_float_array(solution.y, cdata.m)
       s = read_float_array(solution.s, cdata.m)
@@ -185,11 +194,6 @@ module SCS
       end
     end
 
-    # alloc clear memory
-    def calloc(size)
-      Fiddle::Pointer["\x00" * size]
-    end
-
     def ffi
       @ffi
     end

data/lib/scs/version.rb

@@ -1,3 +1,3 @@
 module SCS
-  VERSION = "0.5.5"
+  VERSION = "0.6.0"
 end

data/vendor/scs/CITATION.cff

@@ -10,8 +10,8 @@ authors:
 - family-names: "Boyd"
   given-names: "Stephen"
 title: "SCS: Splitting Conic Solver"
-version: 3.2.11
-date-released: 2023
+version: 3.3.1
+date-released: '2026-09-05'
 url: "https://github.com/cvxgrp/scs"
 
 # Original SCS paper:
@@ -36,4 +36,3 @@ preferred-citation:
   year: 2016
   doi: 10.1007/s10957-016-0892-3
   url: https://dx.doi.org/10.1007/s10957-016-0892-3
-

data/vendor/scs/CLAUDE.md

@@ -0,0 +1,115 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## What This Is
+
+SCS (Splitting Conic Solver) is a C library for solving large-scale convex cone optimization problems (LP, SOCP, SDP, ECP, PCP, complex SDP, spectral cones) using the ADMM splitting algorithm with optional Anderson acceleration.
+
+## Build Commands
+
+```bash
+make                        # Build with BLAS/LAPACK (default)
+make USE_LAPACK=0           # Build without LAPACK (no SDP support)
+make DLONG=1                # Build with 64-bit integer indexing
+make USE_SPECTRAL_CONES=1   # Build with spectral cone support (requires LAPACK)
+make USE_OPENMP=1           # Build with OpenMP parallelization
+make purge                  # Clean all build artifacts
+```
+
+CMake alternative:
+```bash
+mkdir build && cd build
+cmake -DBUILD_TESTING=ON -DUSE_LAPACK=ON ..
+cmake --build .
+```
+
+Outputs go to `out/`: static libs (`libscsdir.a`, `libscsindir.a`), shared libs, and demo/test binaries.
+
+## Testing
+
+```bash
+make test                        # Build test binaries
+./out/run_tests_direct           # Run direct solver tests
+./out/run_tests_indirect         # Run indirect solver tests
+
+# With options:
+make test DLONG=1 USE_LAPACK=1
+```
+
+Tests use the `minunit.h` framework in `test/`. Individual test problems are in `test/problems/` and `test/spectral_cones_problems/`.
+
+## Architecture
+
+### Algorithm
+SCS uses ADMM to split convex cone problems into two alternating steps:
+1. **Linear system solve** — factorizes/solves a KKT-like system
+2. **Cone projection** — projects onto the constraint cone
+
+Anderson acceleration (`src/aa.c`) speeds convergence. Problem normalization/equilibration (`src/normalize.c`) improves conditioning before solving.
+
+### Key Interfaces
+- **`include/linsys.h`** — abstract interface that all linear system solvers must implement; `ScsLinSysWork` is the opaque solver-specific workspace
+- **`include/cones.h`** — cone projection interface; `ScsConeWork` holds precomputed cone data
+- **`include/scs.h`** — public API: `ScsMatrix`, `ScsData`, `ScsCone`, `ScsSettings`, `ScsSolution`
+
+### Linear Solver Backends (in `linsys/`)
+- `cpu/direct/` — QDLDL sparse Cholesky (default, bundled in `linsys/external/qdldl/`)
+- `cpu/indirect/` — iterative (conjugate gradient / LSQR)
+- `mkl/direct/` — Intel MKL Pardiso (enabled via `MKLROOT`)
+- `accelerate/direct/` — Apple Accelerate sparse LDLt (macOS only, `make accelerate`)
+- `cudss/direct/` — NVIDIA cuDSS GPU solver
+- `gpu/indirect/` — GPU iterative solver
+
+The Makefile selects which backend to compile based on flags. Only one direct or indirect backend is linked per build.
+
+### Cone Types
+Supported cones are registered in `src/cones.c`. The `ScsCone` struct fields map to: `z` (zero), `l` (non-negative), `q` (second-order), `s` (PSD), `cs` (complex PSD), `p` (power), `ep`/`ed` (exponential primal/dual). Spectral cones (`USE_SPECTRAL_CONES=1`) add log-determinant, nuclear norm, and sum-of-largest-eigenvalues support via `src/spectral_cones/`.
+
+### Compiler Flags
+Defined in `scs.mk`: `-Wall -Wwrite-strings -pedantic -funroll-loops -Werror=incompatible-pointer-types`. Type aliases `scs_float` and `scs_int` in `include/scs_types.h` change with `SFLOAT` and `DLONG` flags.
+
+## Key Data Flow
+
+The main solve lifecycle is:
+1. **`scs_init`** — validates data, deep-copies and normalizes `A`/`P`/`b`/`c`, sets up linear system solver (factorization for direct), sets up cone workspace
+2. **`scs_solve`** — ADMM loop:
+   - Solve linear system (KKT) to get search direction (`project_lin_sys`)
+   - Project onto dual cone via Moreau decomposition (`project_cones`)
+   - Apply Anderson acceleration every `acceleration_interval` iterations
+   - Check convergence / infeasibility / time limit
+   - Optionally update scale parameter (adaptive scaling)
+3. **`scs_finish`** — frees all workspace memory
+
+`scs_update` allows changing `b`/`c` between solves without re-factorizing.
+
+## Adding a New Linear Solver Backend
+
+1. Create a new directory under `linsys/`, e.g. `linsys/mybackend/direct/`
+2. Implement the 5 functions declared in `include/linsys.h`:
+   - `scs_init_lin_sys_work()` — allocate workspace, factorize if direct
+   - `scs_solve_lin_sys()` — solve the KKT system
+   - `scs_update_lin_sys_diag_r()` — handle R diagonal updates
+   - `scs_free_lin_sys_work()` — deallocate workspace
+   - `scs_get_lin_sys_method()` — return a descriptive string
+3. Create `private.h` defining `struct SCS_LIN_SYS_WORK` with your backend's fields
+4. Add Makefile rules following the pattern of the existing backends (see `mkl`, `cudss`)
+5. Add CMake rules following the same pattern in `CMakeLists.txt`
+6. Add a CI workflow in `.github/workflows/`
+
+See `linsys/cpu/direct/` for the reference implementation.
+
+## Adding a New Cone Type
+
+1. Add the new field(s) to `ScsCone` in `include/scs.h`
+2. In `src/cones.c`:
+   - Update `SCS(validate_cones)` to validate the new cone's parameters
+   - Update `SCS(init_cone)` to compute cone boundaries and allocate workspace
+   - Update `SCS(proj_dual_cone)` to project onto the new cone
+   - Update `SCS(get_cone_header)` for printing
+   - Update `SCS(set_r_y)` for the R diagonal entries
+3. If the projection is complex, put it in a separate source file (like `src/exp_cone.c`)
+4. Update the Makefile object lists and CMakeLists.txt source lists
+5. Add a test in `test/problems/`
+
+Cone ordering in the rows of `A` must match the order in `proj_dual_cone`.