scs 0.5.6 → 0.6.0

data/vendor/scs/test/problems/test_root_plus.h

@@ -0,0 +1,191 @@
+#include "glbopts.h"
+#include "linalg.h"
+#include "minunit.h"
+#include "scs.h"
+
+/*
+ * Test that the stable fused single-loop root_plus computation gives the same
+ * result as the original five-separate-dot_r formulation on well-conditioned
+ * cases and improves a cancellation-prone quadratic.
+ *
+ * root_plus solves: tau = (-b + sqrt(b^2 - 4ac)) / (2a)
+ *   where a = tau_scale + g'Rg
+ *         b = mu'Rg - 2 p'Rg - eta * tau_scale
+ *         c = p'Rp - p'Rmu
+ *   and x'Ry = sum_i x[i]*y[i]*r[i]  (R-weighted dot product)
+ *
+ * The old code computed a, b, c via five separate dot_r calls.
+ * The new code computes all five weighted dot products in one fused loop.
+ * Both must produce the same quadratic formula result.
+ */
+
+/* Old implementation: separate weighted dot products */
+static scs_float dot_r_ref(const scs_float *x, const scs_float *y,
+                           const scs_float *r, scs_int nm) {
+  scs_int i;
+  scs_float ip = 0.0;
+  for (i = 0; i < nm; ++i) {
+    ip += x[i] * y[i] * r[i];
+  }
+  return ip;
+}
+
+static scs_float root_plus_old(const scs_float *g, const scs_float *p,
+                               const scs_float *mu, const scs_float *r,
+                               scs_int nm, scs_float tau_scale,
+                               scs_float eta) {
+  scs_float a, b, c, rad;
+  a = tau_scale + dot_r_ref(g, g, r, nm);
+  b = dot_r_ref(mu, g, r, nm) - 2 * dot_r_ref(p, g, r, nm) -
+      eta * tau_scale;
+  c = dot_r_ref(p, p, r, nm) - dot_r_ref(p, mu, r, nm);
+  rad = b * b - 4 * a * c;
+  return (-b + SQRTF(MAX(rad, 0.))) / (2 * a);
+}
+
+static scs_float root_plus_stable_coeffs(scs_float a, scs_float b,
+                                         scs_float c) {
+  scs_float rad, sqrt_rad, q;
+  if (!isfinite(a) || !isfinite(b) || !isfinite(c) || a <= 0.) {
+    return NAN;
+  }
+  rad = b * b - 4 * a * c;
+  if (!isfinite(rad)) {
+    return NAN;
+  }
+  if (rad < 0.) {
+    return -b / (2 * a);
+  }
+  sqrt_rad = SQRTF(rad);
+  if (b <= 0.) {
+    return (-b + sqrt_rad) / (2 * a);
+  }
+  q = -0.5 * (b + sqrt_rad);
+  return q != 0. ? c / q : 0.;
+}
+
+/* New implementation: fused single loop with stable quadratic formula */
+static scs_float root_plus_new(const scs_float *g, const scs_float *p,
+                               const scs_float *mu, const scs_float *r,
+                               scs_int nm, scs_float tau_scale,
+                               scs_float eta) {
+  scs_int i;
+  scs_float gg = 0., mug = 0., pg = 0., pp = 0., pmu = 0.;
+  scs_float a, b, c;
+  for (i = 0; i < nm; ++i) {
+    scs_float ri = r[i], gi = g[i], pi = p[i], mui = mu[i];
+    gg  += gi  * gi  * ri;
+    mug += mui * gi  * ri;
+    pg  += pi  * gi  * ri;
+    pp  += pi  * pi  * ri;
+    pmu += pi  * mui * ri;
+  }
+  a = tau_scale + gg;
+  b = mug - 2 * pg - eta * tau_scale;
+  c = pp - pmu;
+  return root_plus_stable_coeffs(a, b, c);
+}
+
+static const char *test_root_plus_equivalence(void) {
+  /* Test with several hand-crafted input vectors */
+  scs_int nm;
+  scs_float tau_scale, eta, old_val, new_val, err;
+
+  /* Test case 1: small vector */
+  {
+    scs_float g1[]  = {1.0, -2.0, 0.5};
+    scs_float p1[]  = {0.3, 0.7, -0.1};
+    scs_float mu1[] = {-0.5, 1.2, 0.8};
+    scs_float r1[]  = {2.0, 0.5, 1.5};
+    nm = 3;
+    tau_scale = 1.0;
+    eta = 0.5;
+    old_val = root_plus_old(g1, p1, mu1, r1, nm, tau_scale, eta);
+    new_val = root_plus_new(g1, p1, mu1, r1, nm, tau_scale, eta);
+    err = ABS(old_val - new_val);
+    scs_printf("root_plus case 1: old=%.12e new=%.12e err=%.2e\n",
+               old_val, new_val, err);
+    mu_assert("root_plus case 1 mismatch", err < 1e-12 * MAX(ABS(old_val), 1.));
+  }
+
+  /* Test case 2: larger vector with mixed signs */
+  {
+    scs_float g2[]  = {-0.1, 3.0, -2.5, 0.7, 1.1, -0.3, 0.9, -1.4};
+    scs_float p2[]  = {0.5, -0.8, 1.2, -0.4, 0.6, 2.1, -1.0, 0.3};
+    scs_float mu2[] = {1.0, -1.5, 0.3, 0.8, -0.2, 0.7, 1.3, -0.6};
+    scs_float r2[]  = {0.1, 1.0, 3.0, 0.5, 2.0, 0.8, 1.5, 0.3};
+    nm = 8;
+    tau_scale = 2.5;
+    eta = -0.3;
+    old_val = root_plus_old(g2, p2, mu2, r2, nm, tau_scale, eta);
+    new_val = root_plus_new(g2, p2, mu2, r2, nm, tau_scale, eta);
+    err = ABS(old_val - new_val);
+    scs_printf("root_plus case 2: old=%.12e new=%.12e err=%.2e\n",
+               old_val, new_val, err);
+    mu_assert("root_plus case 2 mismatch", err < 1e-12 * MAX(ABS(old_val), 1.));
+  }
+
+  /* Test case 3: large tau_scale dominates */
+  {
+    scs_float g3[]  = {0.01, -0.02};
+    scs_float p3[]  = {100.0, -50.0};
+    scs_float mu3[] = {200.0, 300.0};
+    scs_float r3[]  = {1.0, 1.0};
+    nm = 2;
+    tau_scale = 1e6;
+    eta = 1.0;
+    old_val = root_plus_old(g3, p3, mu3, r3, nm, tau_scale, eta);
+    new_val = root_plus_new(g3, p3, mu3, r3, nm, tau_scale, eta);
+    err = ABS(old_val - new_val);
+    scs_printf("root_plus case 3: old=%.12e new=%.12e err=%.2e\n",
+               old_val, new_val, err);
+    mu_assert("root_plus case 3 mismatch", err < 1e-10 * MAX(ABS(old_val), 1.));
+  }
+
+  /* Test case 4: near-zero discriminant */
+  {
+    scs_float g4[]  = {1.0, 0.0, 0.0, 0.0, 0.0};
+    scs_float p4[]  = {0.0, 0.0, 0.0, 0.0, 0.0};
+    scs_float mu4[] = {0.0, 0.0, 0.0, 0.0, 0.0};
+    scs_float r4[]  = {1.0, 1.0, 1.0, 1.0, 1.0};
+    nm = 5;
+    tau_scale = 1.0;
+    eta = 0.0;
+    old_val = root_plus_old(g4, p4, mu4, r4, nm, tau_scale, eta);
+    new_val = root_plus_new(g4, p4, mu4, r4, nm, tau_scale, eta);
+    err = ABS(old_val - new_val);
+    scs_printf("root_plus case 4: old=%.12e new=%.12e err=%.2e\n",
+               old_val, new_val, err);
+    mu_assert("root_plus case 4 mismatch", err < 1e-14);
+  }
+
+  /* Test case 5: varying r weights spanning orders of magnitude */
+  {
+    scs_float g5[]  = {0.5, -1.3, 2.1, -0.7, 0.9, 1.1};
+    scs_float p5[]  = {-0.2, 0.8, -1.5, 0.4, -0.6, 1.0};
+    scs_float mu5[] = {0.3, -0.9, 0.6, 1.2, -0.8, 0.1};
+    scs_float r5[]  = {1e-4, 1e-2, 1.0, 1e2, 1e4, 1e6};
+    nm = 6;
+    tau_scale = 0.01;
+    eta = 2.0;
+    old_val = root_plus_old(g5, p5, mu5, r5, nm, tau_scale, eta);
+    new_val = root_plus_new(g5, p5, mu5, r5, nm, tau_scale, eta);
+    err = ABS(old_val - new_val);
+    scs_printf("root_plus case 5: old=%.12e new=%.12e err=%.2e\n",
+               old_val, new_val, err);
+    mu_assert("root_plus case 5 mismatch", err < 1e-10 * MAX(ABS(old_val), 1.));
+  }
+
+  /* Test case 6: cancellation-prone direct formula */
+  {
+    scs_float stable_val, expected;
+    stable_val = root_plus_stable_coeffs(1., 1e8, 1.);
+    expected = -1e-8;
+    err = ABS(stable_val - expected);
+    scs_printf("root_plus case 6: stable=%.12e expected=%.12e err=%.2e\n",
+               stable_val, expected, err);
+    mu_assert("root_plus case 6 cancellation", err < 1e-14);
+  }
+
+  return 0;
+}

data/vendor/scs/test/problems/test_rw_settings.h

@@ -0,0 +1,112 @@
+#include <stdint.h>
+#include <string.h>
+
+#include "cones.h"
+#include "glbopts.h"
+#include "minunit.h"
+#include "rw.h"
+#include "scs.h"
+#include "util.h"
+
+/* Round-trip nondefault settings through write_data/read_data, then
+ * verify the reader is robust to files stamped by OTHER 3.3.x builds:
+ * the settings-block layout is keyed off a numeric version comparison
+ * (>= 3.3.0), not exact string equality, and the extension section
+ * carries its own schema version. */
+
+static const char *test_rw_settings(void) {
+  ScsCone *k = (ScsCone *)scs_calloc(1, sizeof(ScsCone));
+  ScsData *d = (ScsData *)scs_calloc(1, sizeof(ScsData));
+  ScsSettings *stgs = (ScsSettings *)scs_calloc(1, sizeof(ScsSettings));
+  ScsCone *k2 = SCS_NULL;
+  ScsData *d2 = SCS_NULL;
+  ScsSettings *stgs2 = SCS_NULL;
+  const char *fname = "test_rw_settings_data";
+  scs_int pass;
+
+  /* tiny LP: 1 var, 1 nonneg row */
+  scs_float Ax[1] = {1.0};
+  scs_int Ai[1] = {0};
+  scs_int Ap[2] = {0, 1};
+  scs_float b[1] = {1.0};
+  scs_float c[1] = {1.0};
+  ScsMatrix A = {Ax, Ai, Ap, 1, 1};
+  d->m = 1;
+  d->n = 1;
+  d->A = &A;
+  d->b = b;
+  d->c = c;
+  k->l = 1;
+
+  scs_set_default_settings(stgs);
+  /* nondefaults across both layout regions and the extension section */
+  stgs->adaptive_diag_scale = 0; /* v2 extension field */
+  stgs->time_limit_secs = 123.5; /* v1 extension field */
+  stgs->acceleration_type_1 = 0; /* post-3.3.0 stgs-block field */
+  stgs->acceleration_regularization = 3e-9;
+  stgs->eps_abs = 2.5e-7;
+  stgs->write_data_filename = fname;
+
+  SCS(write_data)(d, k, stgs);
+
+  mu_assert("rw_settings: read failed",
+            SCS(read_data)(fname, &d2, &k2, &stgs2) == 0);
+  /* Binary serialization preserves the stored values exactly in either
+   * precision; comparing against double literals would fail with SFLOAT. */
+  pass = stgs2->adaptive_diag_scale == stgs->adaptive_diag_scale &&
+         stgs2->time_limit_secs == stgs->time_limit_secs &&
+         stgs2->acceleration_type_1 == stgs->acceleration_type_1 &&
+         stgs2->acceleration_regularization == stgs->acceleration_regularization &&
+         stgs2->eps_abs == stgs->eps_abs;
+  mu_assert("rw_settings: nondefault round-trip lost a setting", pass);
+  SCS(free_data)(d2);
+  SCS(free_cone)(k2);
+  scs_free(stgs2);
+  d2 = SCS_NULL;
+  k2 = SCS_NULL;
+  stgs2 = SCS_NULL;
+
+  /* Patch the embedded version string to an adjacent 3.3.x build (3.3.9,
+   * padded) and re-read: everything must still parse, since the settings
+   * layout is keyed off the numeric major.minor, not the exact string. */
+  {
+    FILE *f = fopen(fname, "r+b");
+    long pos = 2 * (long)sizeof(uint32_t); /* int_sz, float_sz */
+    uint32_t ver_len;
+    char patched[16];
+    mu_assert("rw_settings: reopen failed", f != SCS_NULL);
+    fseek(f, pos, SEEK_SET);
+    mu_assert("rw_settings: read ver len",
+              fread(&ver_len, sizeof(uint32_t), 1, f) == 1);
+    mu_assert("rw_settings: unexpected version length",
+              ver_len >= 5 && ver_len < 16);
+    /* C requires a positioning call between a read and a write on an
+     * update stream; Windows enforces it. */
+    fseek(f, 0, SEEK_CUR);
+    memset(patched, '9', ver_len); /* "3.3.99...": an adjacent 3.3.x */
+    patched[0] = '3';
+    patched[1] = '.';
+    patched[2] = '3';
+    patched[3] = '.';
+    mu_assert("rw_settings: patch write",
+              fwrite(patched, 1, ver_len, f) == ver_len);
+    fclose(f);
+  }
+  mu_assert("rw_settings: adjacent-version read failed",
+            SCS(read_data)(fname, &d2, &k2, &stgs2) == 0);
+  pass = stgs2->adaptive_diag_scale == stgs->adaptive_diag_scale &&
+         stgs2->time_limit_secs == stgs->time_limit_secs &&
+         stgs2->acceleration_type_1 == stgs->acceleration_type_1 &&
+         stgs2->acceleration_regularization == stgs->acceleration_regularization &&
+         stgs2->eps_abs == stgs->eps_abs;
+  mu_assert("rw_settings: adjacent-version read lost a setting", pass);
+  SCS(free_data)(d2);
+  SCS(free_cone)(k2);
+  scs_free(stgs2);
+
+  remove(fname);
+  scs_free(stgs);
+  scs_free(d);
+  scs_free(k);
+  return 0;
+}

data/vendor/scs/test/problems/test_soc_sizes.h

@@ -0,0 +1,393 @@
+#include "glbopts.h"
+#include "linalg.h"
+#include "minunit.h"
+#include "problem_utils.h"
+#include "scs.h"
+#include "util.h"
+
+/*
+ * SOC size-1 test: proj_soc with q=1 reduces to x[0] = MAX(x[0], 0), i.e.
+ * the non-negative orthant for a single scalar.
+ * Problem: min t  s.t.  t in SOC_1 (t >= 0),  t = 1.5
+ * Optimal: t = 1.5, obj = 1.5.
+ *
+ * Variables [t] (n=1), m=2:
+ *   Row 0 (zero): t = 1.5  -> A[0,0]=1, b[0]=1.5
+ *   Row 1 (SOC_1): s[1] = t  -> A[1,0]=-1, b[1]=0
+ */
+static const char *test_soc_size1(void) {
+  ScsCone *k = (ScsCone *)scs_calloc(1, sizeof(ScsCone));
+  ScsData *d = (ScsData *)scs_calloc(1, sizeof(ScsData));
+  ScsSettings *stgs = (ScsSettings *)scs_calloc(1, sizeof(ScsSettings));
+  ScsSolution *sol = (ScsSolution *)scs_calloc(1, sizeof(ScsSolution));
+  ScsInfo info = {0};
+  scs_int exitflag;
+  scs_float perr, derr;
+  scs_int success;
+  const char *fail;
+
+  scs_float opt = 1.5;
+
+  scs_float Ax[] = {1.0, -1.0};
+  scs_int Ai[]   = {0, 1};
+  scs_int Ap[]   = {0, 2};
+
+  scs_float b[] = {1.5, 0.0};
+  scs_float c[] = {1.0};
+
+  scs_int q[] = {1};
+  scs_int m = 2, n = 1;
+
+  d->m = m;
+  d->n = n;
+  d->b = b;
+  d->c = c;
+
+  d->A = (ScsMatrix *)scs_calloc(1, sizeof(ScsMatrix));
+  d->A->m = m;
+  d->A->n = n;
+  d->A->x = Ax;
+  d->A->i = Ai;
+  d->A->p = Ap;
+
+  k->z = 1;
+  k->qsize = 1;
+  k->q = q;
+
+  scs_set_default_settings(stgs);
+  stgs->eps_abs = 1e-6;
+  stgs->eps_rel = 1e-6;
+
+  exitflag = scs(d, k, stgs, sol, &info);
+
+  perr = info.pobj - opt;
+  derr = info.dobj - opt;
+
+  scs_printf("primal obj error %4e\n", perr);
+  scs_printf("dual obj error %4e\n", derr);
+
+  success = ABS(perr) < 1e-4 && ABS(derr) < 1e-4 && exitflag == SCS_SOLVED;
+  mu_assert("test_soc_size1: SCS failed to produce SCS_SOLVED", success);
+  fail = verify_solution_correct(d, k, stgs, &info, sol, exitflag);
+
+  SCS(free_sol)(sol);
+  scs_free(d->A);
+  scs_free(k);
+  scs_free(stgs);
+  scs_free(d);
+  return fail;
+}
+
+/*
+ * SOC size-2 test: exercises the q=2 fast path in proj_soc.
+ * min t  s.t. (t, x) in SOC_2 (t >= |x|),  x = 1.5
+ * Optimal: t = 1.5, obj = 1.5.
+ *
+ * Variables [t, x] (n=2), m=3:
+ *   Row 0 (zero): x = 1.5  → A[0,1]=1, b[0]=1.5
+ *   Rows 1-2 (SOC_2): s[1:3] = (t, x) in SOC_2
+ *     row 1: -t+s1=0  → s1=t
+ *     row 2: -x+s2=0  → s2=x
+ */
+static const char *test_soc_size2(void) {
+  ScsCone *k = (ScsCone *)scs_calloc(1, sizeof(ScsCone));
+  ScsData *d = (ScsData *)scs_calloc(1, sizeof(ScsData));
+  ScsSettings *stgs = (ScsSettings *)scs_calloc(1, sizeof(ScsSettings));
+  ScsSolution *sol = (ScsSolution *)scs_calloc(1, sizeof(ScsSolution));
+  ScsInfo info = {0};
+  scs_int exitflag;
+  scs_float perr, derr;
+  scs_int success;
+  const char *fail;
+
+  scs_float opt = 1.5;
+
+  scs_float Ax[] = {-1.0, 1.0, -1.0};
+  scs_int Ai[]   = {1, 0, 2};
+  scs_int Ap[]   = {0, 1, 3};
+
+  scs_float b[] = {1.5, 0.0, 0.0};
+  scs_float c[] = {1.0, 0.0};
+
+  scs_int q[] = {2};
+  scs_int m = 3, n = 2;
+
+  d->m = m;
+  d->n = n;
+  d->b = b;
+  d->c = c;
+
+  d->A = (ScsMatrix *)scs_calloc(1, sizeof(ScsMatrix));
+  d->A->m = m;
+  d->A->n = n;
+  d->A->x = Ax;
+  d->A->i = Ai;
+  d->A->p = Ap;
+
+  k->z = 1;
+  k->qsize = 1;
+  k->q = q;
+
+  scs_set_default_settings(stgs);
+  stgs->eps_abs = 1e-6;
+  stgs->eps_rel = 1e-6;
+
+  exitflag = scs(d, k, stgs, sol, &info);
+
+  perr = info.pobj - opt;
+  derr = info.dobj - opt;
+
+  scs_printf("primal obj error %4e\n", perr);
+  scs_printf("dual obj error %4e\n", derr);
+
+  success = ABS(perr) < 1e-4 && ABS(derr) < 1e-4 && exitflag == SCS_SOLVED;
+  mu_assert("test_soc_size2: SCS failed to produce SCS_SOLVED", success);
+  fail = verify_solution_correct(d, k, stgs, &info, sol, exitflag);
+
+  SCS(free_sol)(sol);
+  scs_free(d->A);
+  scs_free(k);
+  scs_free(stgs);
+  scs_free(d);
+  return fail;
+}
+
+/*
+ * SOC size-3 test: exercises the q=3 fast path in proj_soc.
+ * min t  s.t. (t, x1, x2) in SOC_3  (t >= sqrt(x1^2+x2^2)),
+ *              x1 = 1,  x2 = 2
+ * Optimal: t = sqrt(5), obj = sqrt(5).
+ *
+ * Variables [t, x1, x2] (n=3), m=5:
+ *   Row 0 (zero): x1 = 1   → A[0,1]=1, b[0]=1
+ *   Row 1 (zero): x2 = 2   → A[1,2]=1, b[1]=2
+ *   Rows 2-4 (SOC_3): s[2:5] = (t,x1,x2) in SOC_3
+ *     row 2: -t+s2=0, row 3: -x1+s3=0, row 4: -x2+s4=0
+ */
+static const char *test_soc_size3(void) {
+  ScsCone *k = (ScsCone *)scs_calloc(1, sizeof(ScsCone));
+  ScsData *d = (ScsData *)scs_calloc(1, sizeof(ScsData));
+  ScsSettings *stgs = (ScsSettings *)scs_calloc(1, sizeof(ScsSettings));
+  ScsSolution *sol = (ScsSolution *)scs_calloc(1, sizeof(ScsSolution));
+  ScsInfo info = {0};
+  scs_int exitflag;
+  scs_float perr, derr;
+  scs_int success;
+  const char *fail;
+
+  scs_float opt = 2.2360679774997896; /* sqrt(5) */
+
+  scs_float Ax[] = {-1.0, 1.0, -1.0, 1.0, -1.0};
+  scs_int Ai[]   = {2, 0, 3, 1, 4};
+  scs_int Ap[]   = {0, 1, 3, 5};
+
+  scs_float b[] = {1.0, 2.0, 0.0, 0.0, 0.0};
+  scs_float c[] = {1.0, 0.0, 0.0};
+
+  scs_int q[] = {3};
+  scs_int m = 5, n = 3;
+
+  d->m = m;
+  d->n = n;
+  d->b = b;
+  d->c = c;
+
+  d->A = (ScsMatrix *)scs_calloc(1, sizeof(ScsMatrix));
+  d->A->m = m;
+  d->A->n = n;
+  d->A->x = Ax;
+  d->A->i = Ai;
+  d->A->p = Ap;
+
+  k->z = 2;
+  k->qsize = 1;
+  k->q = q;
+
+  scs_set_default_settings(stgs);
+  stgs->eps_abs = 1e-6;
+  stgs->eps_rel = 1e-6;
+
+  exitflag = scs(d, k, stgs, sol, &info);
+
+  perr = info.pobj - opt;
+  derr = info.dobj - opt;
+
+  scs_printf("primal obj error %4e\n", perr);
+  scs_printf("dual obj error %4e\n", derr);
+
+  success = ABS(perr) < 1e-4 && ABS(derr) < 1e-4 && exitflag == SCS_SOLVED;
+  mu_assert("test_soc_size3: SCS failed to produce SCS_SOLVED", success);
+  fail = verify_solution_correct(d, k, stgs, &info, sol, exitflag);
+
+  SCS(free_sol)(sol);
+  scs_free(d->A);
+  scs_free(k);
+  scs_free(stgs);
+  scs_free(d);
+  return fail;
+}
+
+/*
+ * SOC size-5 test: exercises the general (q>3) code path in proj_soc.
+ * min t  s.t.  (t, x1, x2, x3, x4) in SOC_5  (t >= ||(x1..x4)||),
+ *              xi = 1 for i=1..4.
+ * Optimal: t = sqrt(4) = 2, obj = 2.
+ *
+ * Variables [t, x1, x2, x3, x4] (n=5), m=9:
+ *   Rows 0-3 (zero, 4 equalities): xi = 1
+ *   Rows 4-8 (SOC_5): (t, x1, ..., x4) in SOC_5
+ *
+ * A cols (CSC):
+ *   col 0 (t):  row 4 -> -1
+ *   col 1 (x1): row 0 -> +1, row 5 -> -1
+ *   col 2 (x2): row 1 -> +1, row 6 -> -1
+ *   col 3 (x3): row 2 -> +1, row 7 -> -1
+ *   col 4 (x4): row 3 -> +1, row 8 -> -1
+ */
+static const char *test_soc_size5(void) {
+  ScsCone *k = (ScsCone *)scs_calloc(1, sizeof(ScsCone));
+  ScsData *d = (ScsData *)scs_calloc(1, sizeof(ScsData));
+  ScsSettings *stgs = (ScsSettings *)scs_calloc(1, sizeof(ScsSettings));
+  ScsSolution *sol = (ScsSolution *)scs_calloc(1, sizeof(ScsSolution));
+  ScsInfo info = {0};
+  scs_int exitflag;
+  scs_float perr, derr;
+  scs_int success;
+  const char *fail;
+
+  scs_float opt = 2.0; /* sqrt(1^2 + 1^2 + 1^2 + 1^2) = 2 */
+
+  scs_float Ax5[] = {-1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0};
+  scs_int Ai5[]   = {4, 0, 5, 1, 6, 2, 7, 3, 8};
+  scs_int Ap5[]   = {0, 1, 3, 5, 7, 9};
+
+  scs_float b5[] = {1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0};
+  scs_float c5[] = {1.0, 0.0, 0.0, 0.0, 0.0};
+
+  scs_int q5[] = {5};
+  scs_int m = 9, n = 5;
+
+  d->m = m;
+  d->n = n;
+  d->b = b5;
+  d->c = c5;
+
+  d->A = (ScsMatrix *)scs_calloc(1, sizeof(ScsMatrix));
+  d->A->m = m;
+  d->A->n = n;
+  d->A->x = Ax5;
+  d->A->i = Ai5;
+  d->A->p = Ap5;
+
+  k->z = 4;
+  k->qsize = 1;
+  k->q = q5;
+
+  scs_set_default_settings(stgs);
+  stgs->eps_abs = 1e-6;
+  stgs->eps_rel = 1e-6;
+
+  exitflag = scs(d, k, stgs, sol, &info);
+
+  perr = info.pobj - opt;
+  derr = info.dobj - opt;
+
+  scs_printf("primal obj error %4e\n", perr);
+  scs_printf("dual obj error %4e\n", derr);
+
+  success = ABS(perr) < 1e-4 && ABS(derr) < 1e-4 && exitflag == SCS_SOLVED;
+  mu_assert("test_soc_size5: SCS failed to produce SCS_SOLVED", success);
+  fail = verify_solution_correct(d, k, stgs, &info, sol, exitflag);
+
+  SCS(free_sol)(sol);
+  scs_free(d->A);
+  scs_free(k);
+  scs_free(stgs);
+  scs_free(d);
+  return fail;
+}
+
+/*
+ * Multiple SOC cones test (qsize=2): exercises the loop over k->qsize in
+ * proj_cones.
+ *
+ * Problem: minimize t1 + t2
+ *          subject to (t1, x1, x2) in SOC_3    (t1 >= sqrt(x1^2+x2^2))
+ *                     (t2, x3)     in SOC_2    (t2 >= |x3|)
+ *                     x1=1, x2=1, x3=2
+ * Optimal: t1* = sqrt(2), t2* = 2, obj* = sqrt(2)+2 ~= 3.41421.
+ *
+ * Variables [t1, x1, x2, t2, x3] (n=5), m=8:
+ *   Rows 0-2 (z=3): x1=1, x2=1, x3=2
+ *   Rows 3-5 (SOC_3): (t1, x1, x2)
+ *   Rows 6-7 (SOC_2): (t2, x3)
+ *
+ * A cols (CSC):
+ *   col 0 (t1): row 3 -> -1
+ *   col 1 (x1): row 0 -> +1, row 4 -> -1
+ *   col 2 (x2): row 1 -> +1, row 5 -> -1
+ *   col 3 (t2): row 6 -> -1
+ *   col 4 (x3): row 2 -> +1, row 7 -> -1
+ */
+static const char *test_multi_soc(void) {
+  ScsCone *k = (ScsCone *)scs_calloc(1, sizeof(ScsCone));
+  ScsData *d = (ScsData *)scs_calloc(1, sizeof(ScsData));
+  ScsSettings *stgs = (ScsSettings *)scs_calloc(1, sizeof(ScsSettings));
+  ScsSolution *sol = (ScsSolution *)scs_calloc(1, sizeof(ScsSolution));
+  ScsInfo info = {0};
+  scs_int exitflag;
+  scs_float perr, derr;
+  scs_int success;
+  const char *fail;
+
+  scs_float opt = 3.41421356237309504; /* sqrt(2) + 2 */
+
+  scs_float Axm[] = {-1.0, 1.0, -1.0, 1.0, -1.0, -1.0, 1.0, -1.0};
+  scs_int Aim[]   = {3, 0, 4, 1, 5, 6, 2, 7};
+  scs_int Apm[]   = {0, 1, 3, 5, 6, 8};
+
+  scs_float bm[] = {1.0, 1.0, 2.0, 0.0, 0.0, 0.0, 0.0, 0.0};
+  scs_float cm[] = {1.0, 0.0, 0.0, 1.0, 0.0};
+
+  scs_int qm[] = {3, 2};
+  scs_int m = 8, n = 5;
+
+  d->m = m;
+  d->n = n;
+  d->b = bm;
+  d->c = cm;
+
+  d->A = (ScsMatrix *)scs_calloc(1, sizeof(ScsMatrix));
+  d->A->m = m;
+  d->A->n = n;
+  d->A->x = Axm;
+  d->A->i = Aim;
+  d->A->p = Apm;
+
+  k->z = 3;
+  k->qsize = 2;
+  k->q = qm;
+
+  scs_set_default_settings(stgs);
+  stgs->eps_abs = 1e-6;
+  stgs->eps_rel = 1e-6;
+
+  exitflag = scs(d, k, stgs, sol, &info);
+
+  perr = info.pobj - opt;
+  derr = info.dobj - opt;
+
+  scs_printf("primal obj error %4e\n", perr);
+  scs_printf("dual obj error %4e\n", derr);
+
+  success = ABS(perr) < 1e-4 && ABS(derr) < 1e-4 && exitflag == SCS_SOLVED;
+  mu_assert("test_multi_soc: SCS failed to produce SCS_SOLVED", success);
+  fail = verify_solution_correct(d, k, stgs, &info, sol, exitflag);
+
+  SCS(free_sol)(sol);
+  scs_free(d->A);
+  scs_free(k);
+  scs_free(stgs);
+  scs_free(d);
+  return fail;
+}