scs 0.5.6 → 0.6.0

data/vendor/scs/include/glbopts.h

@@ -1,3 +1,12 @@
+/*
+ * Global options, default parameter values, and platform-specific macros.
+ *
+ * Defines printing/memory allocation macros (adapts to MATLAB, Python, R),
+ * math precision macros (float vs double), default solver constants, and
+ * internal algorithm tuning parameters. This is an internal header; the
+ * public API is in scs.h.
+ */
+
 #ifndef GLB_H_GUARD
 #define GLB_H_GUARD
 
@@ -14,7 +23,7 @@ extern "C" {
 
 /* SCS VERSION NUMBER ----------------------------------------------     */
 /* string literals automatically null-terminated */
-#define SCS_VERSION ("3.2.11")
+#define SCS_VERSION ("3.3.1")
 
 /* verbosity level */
 #ifndef VERBOSITY
@@ -34,13 +43,18 @@ extern "C" {
 #define NORMALIZE (1)
 #define WARM_START (0)
 #define ACCELERATION_LOOKBACK (10)
-#define ACCELERATION_INTERVAL (10)
+#define ACCELERATION_INTERVAL (5)
 #define ADAPTIVE_SCALE (1)
+#define ADAPTIVE_DIAG_SCALE (1)
 #define WRITE_DATA_FILENAME (0)
 #define LOG_CSV_FILENAME (0)
 #define TIME_LIMIT_SECS (0.)
 /* Tolerance to check negativity condition for infeasibility */
 #define INFEAS_NEGATIVITY_TOL (1e-9)
+/* Number of consecutive residual checks an infeasibility/unboundedness
+ * certificate must pass before SCS declares it. Guards against transient
+ * iterates (e.g. from acceleration) that momentarily pass a one-shot test. */
+#define CERT_PERSISTENCE_CHECKS (2)
 /* redefine printfs as needed */
 #if NO_PRINTING > 0     /* Disable all printing */
 #define scs_printf(...) /* No-op */
@@ -74,10 +88,27 @@ extern "C" {
 /* redefine memory allocators as needed */
 #ifdef MATLAB_MEX_FILE
 #include "mex.h"
+/* Use mexMakeMemoryPersistent so allocations survive across MEX calls.
+ * Required for the workspace API (scs_init/scs_solve/scs_finish). */
+static inline void *_scs_mex_malloc(size_t n) {
+  void *p = mxMalloc(n);
+  if (p) mexMakeMemoryPersistent(p);
+  return p;
+}
+static inline void *_scs_mex_calloc(size_t count, size_t size) {
+  void *p = mxCalloc(count, size);
+  if (p) mexMakeMemoryPersistent(p);
+  return p;
+}
+static inline void *_scs_mex_realloc(void *ptr, size_t n) {
+  void *p = mxRealloc(ptr, n);
+  if (p) mexMakeMemoryPersistent(p);
+  return p;
+}
 #define scs_free mxFree
-#define scs_malloc mxMalloc
-#define scs_calloc mxCalloc
-#define scs_realloc mxRealloc
+#define scs_malloc _scs_mex_malloc
+#define scs_calloc _scs_mex_calloc
+#define scs_realloc _scs_mex_realloc
 #elif defined PYTHON
 #include <Python.h>
 #if PY_MAJOR_VERSION >= 3
@@ -113,17 +144,17 @@ static inline void *scs_calloc(size_t count, size_t size) {
 
 #ifndef SFLOAT
 #ifndef NAN
-#define NAN ((scs_float)0x7ff8000000000000)
+#define NAN (HUGE_VAL - HUGE_VAL)
 #endif
 #ifndef INFINITY
-#define INFINITY NAN
+#define INFINITY HUGE_VAL
 #endif
 #else
 #ifndef NAN
-#define NAN ((float)0x7fc00000)
+#define NAN ((float)(HUGE_VAL - HUGE_VAL))
 #endif
 #ifndef INFINITY
-#define INFINITY NAN
+#define INFINITY ((float)HUGE_VAL)
 #endif
 #endif
 
@@ -155,12 +186,14 @@ static inline void *scs_calloc(size_t count, size_t size) {
 #define IABS abs
 #endif
 
-/* Force SCS to treat the problem as (non-homogeneous) feasible for this many */
-/* iters. This acts like a warm-start that biases towards feasibility, which */
-/* is the most common use-case */
+/* Force SCS to treat the problem as (non-homogeneous) feasible for this many
+ * iterations. Acts like an implicit warm-start biased towards feasibility,
+ * which is the most common use-case. During these iterations tau is fixed
+ * at 1 and kappa is fixed at 0. */
 #define FEASIBLE_ITERS (1)
 
-/* how many iterations between heuristic residual rescaling */
+/* Minimum iterations between heuristic scale updates. Prevents scale
+ * from changing too frequently before the iterates have stabilized. */
 #define RESCALING_MIN_ITERS (100)
 
 #define _DIV_EPS_TOL (1E-18)
@@ -185,38 +218,92 @@ static inline void *scs_calloc(size_t count, size_t size) {
 /* #define NORM SCS(norm_2) */
 #define NORM SCS(norm_inf)
 
-/* Factor which is scales tau in the linear system update */
-/* Larger factors prevent tau from moving as much */
+/* Factor which scales the tau diagonal entry in the linear system.
+ * Larger values stabilize tau but slow convergence. 10 is a good balance
+ * for most problems. */
 #define TAU_FACTOR (10.)
 
-/* Anderson acceleration parameters: */
+/* --- Anderson Acceleration (AA) parameters --- */
+/* Default AA type: 1 = type-I (better empirical performance, default),
+ * 0 = type-II (more numerically stable but typically slower). */
+#define ACCELERATION_TYPE_1 (1)
+/* Default Tikhonov regularization for the AA least-squares solve. Tuned
+ * for type-I; type-II tolerates much smaller (e.g. 1e-12). Users picking
+ * type-II will typically lower this. */
+#define AA_REGULARIZATION (1e-8)
 #define AA_RELAXATION (1.0)
-#define AA_REGULARIZATION_TYPE_1 (1e-6)
-#define AA_REGULARIZATION_TYPE_2 (1e-10)
-/* Safeguarding norm factor at which we reject AA steps */
+/* Reject AA steps when the output norm exceeds this multiple of the input
+ * norm. 1.0 means the AA step must not increase the iterate norm. */
 #define AA_SAFEGUARD_FACTOR (1.)
-/* Max allowable AA weight norm */
+/* Reject AA steps whose weight vector exceeds this norm (prevents
+ * numerically unstable extrapolation). */
 #define AA_MAX_WEIGHT_NORM (1e10)
+/* Max iterative-refinement passes on the γ solve. 0 disables IR; the loop
+ * auto-stops once the correction no longer contracts, so this is an upper
+ * bound rather than a fixed iteration count. */
+#define AA_IR_MAX_STEPS (5)
 
 /* (Dual) Scale updating parameters */
 #define MAX_SCALE_VALUE (1e6)
 #define MIN_SCALE_VALUE (1e-6)
 #define SCALE_NORM NORM /* what norm to use when computing the scale factor */
 
-/* CG == Conjugate gradient */
-/* Linear system tolerances, only used with indirect */
+/* Dynamic diagonal rescaling (stgs->adaptive_diag_scale). Row multipliers
+ * move by at most (profile ratio)^DIAG_SCALE_DAMP per update and live in
+ * [DIAG_SCALE_MULT_MIN, DIAG_SCALE_MULT_MAX] around the scalar scale. An
+ * update fires when the scalar scale updates, or when some damped
+ * *clamped* step alone exceeds sqrt(10) (a railed scalar must not freeze
+ * the diagonal; a railed multiplier must not keep triggering updates it
+ * cannot take). */
+#define DIAG_SCALE_DAMP (0.25)
+#define DIAG_SCALE_MULT_MIN (1e-3)
+#define DIAG_SCALE_MULT_MAX (1e3)
+/* Floor on the row-profile denominators, as a fraction of the block's
+ * rms denominator (see row_rel_res). Swept over 1e-4..1e-1: every value
+ * improves on no floor, 1e-3 is the best on solve count. */
+#define DEN_FLOOR_FRAC (1e-3)
+
+/* --- Conjugate gradient (CG) parameters, only used with indirect solver --- */
 #define CG_BEST_TOL (1e-12)
-/* This scales the current residuals to get the tolerance we solve the
- * linear system to at each iteration. Lower factors require more CG steps
- * but give better accuracy */
+/* Each CG solve targets tol = CG_TOL_FACTOR * current_residual. Smaller
+ * values give more accurate CG solves at the cost of more CG iterations.
+ * With deflation making inner accuracy cheap, 0.03 measured optimal on a
+ * netlib / Maros-Meszaros / SOC suite (bracketed on both sides: 0.02
+ * starts flipping problems, 0.01 pays more CG for no outer-iteration
+ * gain); together with CG_RATE 2.0 it buys roughly 30% fewer outer
+ * iterations for roughly 8% more matvecs, which is wall-clock neutral
+ * on matvec-dominated problems and favorable on cone-dominated ones.
+ * The retuned values target accuracies below the single-precision noise
+ * floor, so single-precision builds keep the previous calibration. */
+#ifdef SFLOAT
 #define CG_TOL_FACTOR (0.2)
+#else
+#define CG_TOL_FACTOR (0.03)
+#endif
 
 /* norm to use when deciding CG convergence */
 #ifndef CG_NORM
 #define CG_NORM SCS(norm_inf)
 #endif
-/* cg tol ~ O(1/k^(CG_RATE)) */
+/* cg tol ~ O(1/k^(CG_RATE)); forcing accuracy faster with the iteration
+ * count is consumed by the outer loop (Anderson acceleration
+ * especially) as fewer iterations. 2.0 is safely interior: 2.25 starts
+ * flipping problems. Single precision keeps the previous rate for the
+ * same reason as CG_TOL_FACTOR above. */
+#ifdef SFLOAT
 #define CG_RATE (1.5)
+#else
+#define CG_RATE (2.0)
+#endif
+/* Number of approximate small eigenvectors of the preconditioned
+ * reduced operator harvested from each cold solve for g = K^{-1}h and
+ * used to deflate the warm solves until the next metric change (eigCG,
+ * Stathopoulos & Orginos 2010). Costs 2 * DEFLATE_VECTORS * n floats
+ * persistent plus a transient Lanczos window during the deep solve;
+ * needs USE_LAPACK and is compiled out without it. 0 disables. The
+ * environment variables SCS_DEFLATE and SCS_EIGCG_WIN override the
+ * count and the window size at runtime. */
+#define DEFLATE_VECTORS (30)
 
 #ifdef __cplusplus
 }

data/vendor/scs/include/linalg.h

@@ -1,3 +1,8 @@
+/*
+ * Basic dense linear algebra operations used throughout SCS.
+ * All operate on raw arrays of scs_float.
+ */
+
 #ifndef LINALG_H_GUARD
 #define LINALG_H_GUARD
 
@@ -6,7 +11,6 @@ extern "C" {
 #endif
 
 #include "glbopts.h"
-#include <math.h>
 
 void SCS(scale_array)(scs_float *a, const scs_float b, scs_int len);
 scs_float SCS(dot)(const scs_float *x, const scs_float *y, scs_int len);

data/vendor/scs/include/linsys.h

@@ -6,7 +6,6 @@ extern "C" {
 #endif
 
 #include "glbopts.h"
-#include "scs.h"
 
 /* This is the API that any new linear system solver must implement */
 
@@ -62,7 +61,7 @@ scs_int scs_solve_lin_sys(ScsLinSysWork *w, scs_float *b, const scs_float *s,
  *  @param  new_diag_r    Updated `diag_r`, diagonal entries of R.
  *
  */
-void scs_update_lin_sys_diag_r(ScsLinSysWork *w, const scs_float *new_diag_r);
+scs_int scs_update_lin_sys_diag_r(ScsLinSysWork *w, const scs_float *new_diag_r);
 
 /**
  * Name of the linear solver.

data/vendor/scs/include/normalize.h

@@ -1,3 +1,9 @@
+/*
+ * Problem data normalization (equilibration) routines.
+ * Applied before solving to improve numerical conditioning; undone
+ * after solving to return the solution in the original scale.
+ */
+
 #ifndef NORMALIZE_H_GUARD
 #define NORMALIZE_H_GUARD
 
@@ -11,8 +17,6 @@ extern "C" {
 void SCS(normalize_b_c)(ScsScaling *scal, scs_float *b, scs_float *c);
 void SCS(normalize_sol)(ScsScaling *scal, ScsSolution *sol);
 void SCS(un_normalize_sol)(ScsScaling *scal, ScsSolution *sol);
-void SCS(un_normalize_primal)(ScsScaling *scal, scs_float *r);
-void SCS(un_normalize_dual)(ScsScaling *scal, scs_float *r);
 
 #ifdef __cplusplus
 }

data/vendor/scs/include/rw.h

@@ -1,3 +1,9 @@
+/*
+ * Read/write utilities for serializing SCS problem data to binary files
+ * and logging solve progress to CSV. Disabled when compiled with
+ * NO_READ_WRITE=1.
+ */
+
 #ifndef RW_H_GUARD
 #define RW_H_GUARD
 
@@ -6,15 +12,15 @@ extern "C" {
 #endif
 
 #include "glbopts.h"
-#include "scs.h"
 #include "util.h"
 
 void SCS(write_data)(const ScsData *d, const ScsCone *k,
                      const ScsSettings *stgs);
 scs_int SCS(read_data)(const char *filename, ScsData **d, ScsCone **k,
                        ScsSettings **stgs);
-void SCS(log_data_to_csv)(const ScsCone *k, const ScsSettings *stgs,
-                          const ScsWork *w, scs_int iter,
+scs_int SCS(open_csv_log_file)(ScsWork *w);
+void SCS(close_csv_log_file)(ScsWork *w);
+void SCS(log_data_to_csv)(const ScsCone *k, const ScsWork *w, scs_int iter,
                           SCS(timer) * solve_timer);
 
 #ifdef __cplusplus

data/vendor/scs/include/scs.h

@@ -14,6 +14,7 @@ extern "C" {
 
 /* Contains definitions of primitive types `scs_int` and `scs_float`. */
 #include "scs_types.h"
+#include "aa_stats.h"
 
 #define SCS_NULL 0 /* NULL type */
 
@@ -64,6 +65,12 @@ typedef struct {
   scs_float scale;
   /** Whether to adaptively update `scale`. */
   scs_int adaptive_scale;
+  /** Dynamic diagonal rescaling from residual profiles: 0 = off,
+   *  1 = per-row (rescales the R_y diagonal from the row-wise primal
+   *  residual profile; uniform within non-polyhedral cone blocks; the
+   *  default). Requires `adaptive_scale` (silently disabled without
+   *  it). */
+  scs_int adaptive_diag_scale;
   /** Primal constraint scaling factor. */
   scs_float rho_x;
   /** Maximum iterations to take. */
@@ -82,10 +89,17 @@ typedef struct {
   scs_int verbose;
   /** Whether to use warm start (put initial guess in ScsSolution struct). */
   scs_int warm_start;
-  /** Memory for acceleration. */
+  /** Memory for acceleration. Set to 0 to disable AA. Must be nonnegative. */
   scs_int acceleration_lookback;
   /** Interval to apply acceleration. */
   scs_int acceleration_interval;
+  /** Whether AA uses type-I (1) or type-II (0). */
+  scs_int acceleration_type_1;
+  /** Tikhonov regularization for the AA least-squares solve.
+   *  See `aa_init` in include/aa.h for the sign-encoded modes. */
+  scs_float acceleration_regularization;
+  /** AA relaxation factor in [0, 2]. 1.0 recovers vanilla AA. */
+  scs_float acceleration_relaxation;
   /** String, if set will dump raw prob data to this file. */
   const char *write_data_filename;
   /** String, if set will log data to this csv file (makes SCS very slow). */
@@ -218,6 +232,8 @@ typedef struct {
   scs_int rejected_accel_steps;
   /** Number of accepted AA steps. */
   scs_int accepted_accel_steps;
+  /** Detailed Anderson acceleration diagnostics. */
+  AaStats aa_stats;
   /** Total time (milliseconds) spent in the linear system solver. */
   scs_float lin_sys_time;
   /** Total time (milliseconds) spent in the cone projection. */

data/vendor/scs/include/scs_blas.h

@@ -1,3 +1,10 @@
+/*
+ * BLAS/LAPACK function name mangling macros.
+ * Handles single/double precision prefixes (s/d) and platform-specific
+ * suffixes (underscore, no suffix, etc.) for linking against various
+ * BLAS libraries. Only active when USE_LAPACK is defined.
+ */
+
 #ifndef SCS_BLAS_H_GUARD
 #define SCS_BLAS_H_GUARD
 
@@ -42,6 +49,7 @@ extern "C" {
 #endif
 
 #ifdef MATLAB_MEX_FILE
+#include <stddef.h> /* ptrdiff_t */
 typedef ptrdiff_t blas_int;
 #elif defined BLAS64
 #include <stdint.h>

data/vendor/scs/include/scs_types.h

@@ -26,10 +26,10 @@ typedef int scs_int;
 
 #ifndef SFLOAT
 typedef double scs_float;
-typedef double scs_complex_float[2]; // [real, imaginary]
+typedef double scs_complex_float[2]; /* [real, imaginary] */
 #else
 typedef float scs_float;
-typedef float scs_complex_float[2]; // [real, imaginary]
+typedef float scs_complex_float[2]; /* [real, imaginary] */
 #endif
 
 #ifdef __cplusplus

data/vendor/scs/include/scs_work.h

@@ -1,10 +1,19 @@
 /*
- * Define ScsWork and related internal-only structs (not part of external API).
+ * Internal workspace structs used during the solve.
+ *
+ * ScsWork holds all mutable state for one solve: ADMM iterates, residuals,
+ * normalization data, and pointers to the linear system and cone workspaces.
+ * ScsScaling holds the diagonal matrices from Ruiz equilibration.
+ * ScsResiduals tracks primal/dual residuals and infeasibility certificates.
+ *
+ * These are internal to SCS -- the public API is in scs.h.
  */
 
 #ifndef SCS_WORK_H_GUARD
 #define SCS_WORK_H_GUARD
 
+#include <stdio.h>
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -17,6 +26,9 @@ typedef struct {
   scs_int m;        /* Length of D */
   scs_int n;        /* Length of E */
   scs_float primal_scale, dual_scale;
+  /* accumulated tau-slot scaling from the stacked-operator equilibration;
+   * becomes the sigma applied to b, c in normalize_b_c */
+  scs_float tau_scale;
 } ScsScaling;
 
 /** Holds residual information. */
@@ -56,10 +68,14 @@ struct SCS_WORK {
   scs_float *diag_r; /* vector of R matrix diagonals (affects cone proj) */
   scs_float *b_orig, *c_orig;     /* original unnormalized b and c vectors */
   scs_float nm_b_orig, nm_c_orig; /* unnormalized NORM(b), NORM(c) */
+  scs_float nm_a_orig;            /* unnormalized max abs entry of A */
+  /* consecutive checks the infeas/unbdd certificate has passed */
+  scs_int infeas_cert_streak, unbdd_cert_streak;
   AaWork *accel;                  /* struct for acceleration workspace */
   ScsData *d;                     /* Problem data deep copy NORMALIZED */
   ScsCone *k;                     /* Problem cone deep copy */
   ScsSettings *stgs;      /* contains solver settings specified by user */
+  FILE *log_csv_fout;     /* open CSV log stream for current solve */
   ScsLinSysWork *p;       /* struct populated by linear system solver */
   ScsScaling *scal;       /* contains the re-scaling data */
   ScsConeWork *cone_work; /* workspace for the cone projection step */
@@ -70,6 +86,11 @@ struct SCS_WORK {
   /* Scale updating workspace */
   scs_float sum_log_scale_factor;
   scs_int last_scale_update_iter, n_log_scale_factor, scale_updates;
+  /* per-row scale multipliers on R_y, size m (adaptive_diag_scale >= 1) */
+  scs_float *scale_mults;
+  /* floor on the row-profile denominators, see row_rel_res */
+  scs_float den_floor;
+  /* per-column multipliers on rho_x, size n (adaptive_diag_scale >= 2) */
   /* AA stats */
   scs_float aa_norm;
   scs_int rejected_accel_steps, accepted_accel_steps;

data/vendor/scs/include/util.h

@@ -5,11 +5,8 @@
 extern "C" {
 #endif
 
-#include "cones.h"
 #include "scs.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
+#include "glbopts.h"
 
 /* timing code courtesy of A. Domahidi */
 #if (defined NO_TIMER)
@@ -46,8 +43,8 @@ typedef struct SCS(timer) {
 void SCS(tic)(SCS(timer) * t);
 scs_float SCS(tocq)(SCS(timer) * t);
 void SCS(free_sol)(ScsSolution *sol);
-void SCS(deep_copy_data)(ScsData *dest, const ScsData *src);
-void SCS(deep_copy_stgs)(ScsSettings *dest, const ScsSettings *src);
+scs_int SCS(deep_copy_data)(ScsData *dest, const ScsData *src);
+scs_int SCS(deep_copy_stgs)(ScsSettings *dest, const ScsSettings *src);
 void SCS(free_data)(ScsData *d);
 
 #ifdef __cplusplus

data/vendor/scs/include/util_spectral_cones.h

@@ -23,7 +23,7 @@ void non_neg_proj(const scs_float *src, scs_float *dst, scs_int n);
 scs_float sum_log(const scs_float *x, scs_int n);
 scs_float min_vec(const scs_float *vec, scs_int n);
 
-// used for sorting in ell1-norm cone and sum of largest cone.
+/* used for sorting in ell1-norm cone and sum of largest cone. */
 typedef struct {
   scs_float value;
   int index;
@@ -32,10 +32,10 @@ typedef struct {
 typedef struct {
   int iter;
 
-  // if plain Newton computed the projection or if an IPM was used
+  /* if plain Newton computed the projection or if an IPM was used */
   int newton_success;
 
-  // dual_res, pri_res, complementarity for the projection problem
+  /* dual_res, pri_res, complementarity for the projection problem */
   scs_float residuals[3];
 } Newton_stats;
 

data/vendor/scs/linsys/accelerate/direct/private.c

@@ -0,0 +1,126 @@
+#include "private.h"
+
+#ifdef DLONG
+#error "Apple Accelerate backend does not support DLONG (64-bit integers)"
+#endif
+
+const char *scs_get_lin_sys_method(void) {
+  return "sparse-direct-apple-accelerate";
+}
+
+ScsLinSysWork *scs_init_lin_sys_work(const ScsMatrix *A, const ScsMatrix *P,
+                                     const scs_float *diag_r) {
+  scs_int i, n_plus_m;
+  ScsLinSysWork *p = (ScsLinSysWork *)scs_calloc(1, sizeof(ScsLinSysWork));
+  if (!p) {
+    return SCS_NULL;
+  }
+
+  n_plus_m = A->n + A->m;
+  p->m = A->m;
+  p->n = A->n;
+
+  p->diag_p = (scs_float *)scs_calloc(A->n, sizeof(scs_float));
+  p->diag_r_idxs = (scs_int *)scs_calloc(n_plus_m, sizeof(scs_int));
+  if (!p->diag_p || !p->diag_r_idxs) {
+    scs_free_lin_sys_work(p);
+    return SCS_NULL;
+  }
+
+  /* Form upper triangular KKT matrix in CSC format */
+  p->kkt = SCS(form_kkt)(A, P, p->diag_p, diag_r, p->diag_r_idxs, 1);
+  if (!p->kkt) {
+    scs_printf("Error in forming KKT matrix.\n");
+    scs_free_lin_sys_work(p);
+    return SCS_NULL;
+  }
+
+  /* Convert column starts from scs_int (int) to long for Accelerate API */
+  p->col_starts = (long *)scs_calloc(n_plus_m + 1, sizeof(long));
+  if (!p->col_starts) {
+    scs_free_lin_sys_work(p);
+    return SCS_NULL;
+  }
+  for (i = 0; i <= n_plus_m; i++) {
+    p->col_starts[i] = (long)p->kkt->p[i];
+  }
+
+  /* Set up Accelerate sparse matrix wrapper pointing to KKT data */
+#ifdef SFLOAT
+  p->accel_mat = (SparseMatrix_Float){
+#else
+  p->accel_mat = (SparseMatrix_Double){
+#endif
+      .structure = {.rowCount = n_plus_m,
+                    .columnCount = n_plus_m,
+                    .columnStarts = p->col_starts,
+                    .rowIndices = p->kkt->i,
+                    .attributes =
+                        {
+                            .kind = SparseSymmetric,
+                            .triangle = SparseUpperTriangle,
+                        },
+                    .blockSize = 1},
+      .data = p->kkt->x};
+
+  /* Perform symbolic and numeric factorization */
+  p->factorization =
+      SparseFactor(SparseFactorizationLDLTUnpivoted, p->accel_mat);
+  if (p->factorization.status != SparseStatusOK) {
+    scs_printf("Error in Apple Accelerate LDLt factorization: %d\n",
+               (int)p->factorization.status);
+    SparseCleanup(p->factorization);
+    scs_free_lin_sys_work(p);
+    return SCS_NULL;
+  }
+  p->factorizations++;
+
+  return p;
+}
+
+scs_int scs_solve_lin_sys(ScsLinSysWork *p, scs_float *b, const scs_float *s,
+                          scs_float tol) {
+  scs_int n_plus_m = p->n + p->m;
+#ifdef SFLOAT
+  DenseVector_Float bvec = {.count = n_plus_m, .data = b};
+#else
+  DenseVector_Double bvec = {.count = n_plus_m, .data = b};
+#endif
+  SparseSolve(p->factorization, bvec);
+  return 0;
+}
+
+scs_int scs_update_lin_sys_diag_r(ScsLinSysWork *p, const scs_float *diag_r) {
+  scs_int i;
+  for (i = 0; i < p->n; ++i) {
+    /* top left is R_x + P, bottom right is -R_y */
+    p->kkt->x[p->diag_r_idxs[i]] = p->diag_p[i] + diag_r[i];
+  }
+  for (i = p->n; i < p->n + p->m; ++i) {
+    /* top left is R_x + P, bottom right is -R_y */
+    p->kkt->x[p->diag_r_idxs[i]] = -diag_r[i];
+  }
+
+  /* Refactor with updated values (reuses symbolic factorization) */
+  SparseRefactor(p->accel_mat, &(p->factorization));
+  if (p->factorization.status != SparseStatusOK) {
+    scs_printf("Error in Apple Accelerate LDLt refactorization: %d\n",
+               (int)p->factorization.status);
+    return -1;
+  }
+  p->factorizations++;
+  return 0;
+}
+
+void scs_free_lin_sys_work(ScsLinSysWork *p) {
+  if (p) {
+    if (p->factorizations > 0) {
+      SparseCleanup(p->factorization);
+    }
+    SCS(cs_spfree)(p->kkt);
+    scs_free(p->diag_p);
+    scs_free(p->diag_r_idxs);
+    scs_free(p->col_starts);
+    scs_free(p);
+  }
+}

data/vendor/scs/linsys/accelerate/direct/private.h

@@ -0,0 +1,34 @@
+#ifndef PRIV_H_GUARD
+#define PRIV_H_GUARD
+
+#include <Accelerate/Accelerate.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "csparse.h"
+#include "glbopts.h"
+#include "linsys.h"
+#include "scs_matrix.h"
+
+struct SCS_LIN_SYS_WORK {
+  scs_int m, n;
+  ScsMatrix *kkt;         /* Upper triangular KKT matrix (CSC format) */
+  scs_int *diag_r_idxs;  /* Indices where R appears in kkt->x */
+  scs_float *diag_p;     /* Diagonal values of P */
+  long *col_starts;       /* Column starts converted to long for Accelerate */
+#ifdef SFLOAT
+  SparseMatrix_Float accel_mat;
+  SparseOpaqueFactorization_Float factorization;
+#else
+  SparseMatrix_Double accel_mat;
+  SparseOpaqueFactorization_Double factorization;
+#endif
+  scs_int factorizations; /* Number of successful factorizations */
+};
+
+#ifdef __cplusplus
+}
+#endif
+#endif