scs 0.5.6 → 0.6.0

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

@@ -0,0 +1,64 @@
+/*
+ * Small QP with a fully dense A matrix.
+ * This is the regime where the dense direct backend (Gram + Cholesky)
+ * should outperform the sparse direct backend (QDLDL), because QDLDL
+ * fill-in destroys sparsity while the dense backend uses optimized BLAS.
+ *
+ * n = 20 variables, m = 200 constraints, A fully dense (col_nnz = m).
+ */
+#include "glbopts.h"
+#include "minunit.h"
+#include "problem_utils.h"
+#include "scs.h"
+#include "util.h"
+
+static const char *dense_qp(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));
+  ScsSolution *opt_sol = (ScsSolution *)scs_calloc(1, sizeof(ScsSolution));
+  ScsInfo info = {0};
+  scs_float p_f = 0.1;
+  int seed = 5678;
+  scs_int n = 20;
+  scs_int m = 200;
+  /* col_nnz = m makes A fully dense */
+  scs_int col_nnz = m;
+  scs_int nnz = n * col_nnz;
+  scs_int exitflag;
+  scs_float perr, derr;
+  scs_int success;
+  const char *fail;
+
+  k->z = (scs_int)floor(m * p_f);
+  k->l = m - k->z;
+
+  d->m = m;
+  d->n = n;
+  d->P = SCS_NULL;
+  gen_random_prob_data(nnz, col_nnz, d, k, opt_sol, seed);
+  scs_set_default_settings(stgs);
+  stgs->eps_abs = 1e-5;
+  stgs->eps_rel = 1e-5;
+
+  exitflag = scs(d, k, stgs, sol, &info);
+
+  perr = SCS(dot)(d->c, sol->x, d->n) - SCS(dot)(d->c, opt_sol->x, d->n);
+  derr = -SCS(dot)(d->b, sol->y, d->m) + SCS(dot)(d->b, opt_sol->y, d->m);
+  scs_printf("true obj %4e\n", SCS(dot)(d->c, opt_sol->x, d->n));
+  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("dense_qp: SCS failed to produce outputflag SCS_SOLVED", success);
+  fail = verify_solution_correct(d, k, stgs, &info, sol, exitflag);
+  SCS(free_data)(d);
+  SCS(free_cone)(k);
+  SCS(free_sol)(sol);
+  SCS(free_sol)(opt_sol);
+  scs_free(stgs);
+
+  return fail;
+}

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

@@ -7,6 +7,7 @@
 #include "util.h"
 
 static const char *hs21_tiny_qp(void) {
+  scs_int cold_iter;
   ScsCone *k = (ScsCone *)scs_calloc(1, sizeof(ScsCone));
   ScsData *d = (ScsData *)scs_calloc(1, sizeof(ScsData));
   ScsSettings *stgs = (ScsSettings *)scs_calloc(1, sizeof(ScsSettings));
@@ -83,12 +84,15 @@ static const char *hs21_tiny_qp(void) {
   mu_assert("hs21_tiny_qp: SCS failed to produce outputflag SCS_SOLVED",
             success);
   fail = verify_solution_correct(d, k, stgs, &info, sol, exitflag);
+  cold_iter = info.iter;
 
   /* test warm-starting */
   stgs->warm_start = 1;
   exitflag = scs(d, k, stgs, sol, &info);
-  /* 25 iters should be enough if warm-started */
-  mu_assert("hs21_tiny_qp: warm-start failure", info.iter <= 25);
+  /* relative to the cold solve: an absolute cap encodes the iteration
+   * count of one particular metric and breaks whenever the scaling
+   * changes, even though the warm solve is correct */
+  mu_assert("hs21_tiny_qp: warm-start failure", info.iter <= cold_iter / 2);
   success = ABS(perr) < 1e-4 && ABS(derr) < 1e-4 && exitflag == SCS_SOLVED;
 
   mu_assert("hs21_tiny_qp: SCS failed to produce outputflag SCS_SOLVED",

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

@@ -9,6 +9,7 @@
 
 /* test read / write logic */
 static const char *hs21_tiny_qp_rw(void) {
+  scs_int cold_iter;
   ScsCone *k = (ScsCone *)scs_calloc(1, sizeof(ScsCone));
   ScsData *d = (ScsData *)scs_calloc(1, sizeof(ScsData));
   ScsSettings *stgs = (ScsSettings *)scs_calloc(1, sizeof(ScsSettings));
@@ -74,6 +75,7 @@ static const char *hs21_tiny_qp_rw(void) {
 
   stgs->write_data_filename = "hs21_tiny_qp";
   stgs->max_iters = 1;
+  stgs->time_limit_secs = 123.;
 
   exitflag = scs(d, k, stgs, sol, &info);
 
@@ -90,6 +92,9 @@ static const char *hs21_tiny_qp_rw(void) {
     return "Data read failure, exit.\n";
   }
 
+  mu_assert("hs21_tiny_qp: time_limit_secs failed to round-trip",
+            ABS(stgs->time_limit_secs - 123.) < 1e-12);
+
   stgs->max_iters = 1000;
   /* solve with read data */
   exitflag = scs(d, k, stgs, sol, &info);
@@ -105,12 +110,15 @@ static const char *hs21_tiny_qp_rw(void) {
   mu_assert("hs21_tiny_qp: SCS failed to produce outputflag SCS_SOLVED",
             success);
   fail = verify_solution_correct(d, k, stgs, &info, sol, exitflag);
+  cold_iter = info.iter;
 
   /* test warm-starting */
   stgs->warm_start = 1;
   exitflag = scs(d, k, stgs, sol, &info);
-  /* 25 iters should be enough if warm-started */
-  mu_assert("hs21_tiny_qp: warm-start failure", info.iter <= 25);
+  /* relative to the cold solve: an absolute cap encodes the iteration
+   * count of one particular metric and breaks whenever the scaling
+   * changes, even though the warm solve is correct */
+  mu_assert("hs21_tiny_qp_rw: warm-start failure", info.iter <= cold_iter / 2);
   success = ABS(perr) < 1e-4 && ABS(derr) < 1e-4 && exitflag == SCS_SOLVED;
 
   mu_assert("hs21_tiny_qp: SCS failed to produce outputflag SCS_SOLVED",

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

@@ -0,0 +1,66 @@
+#include "glbopts.h"
+#include "linalg.h"
+#include "minunit.h"
+#include "problem_utils.h"
+#include "scs.h"
+#include "util.h"
+
+/*
+ * Infeasible LP: x >= 1  AND  x <= 0 (contradictory).
+ *
+ * SCS form: min c'x, Ax + s = b, s in K_nn (l=2)
+ *   row 0: -x + s0 = -1, s0 >= 0  =>  x >= 1
+ *   row 1:  x + s1 =  0, s1 >= 0  =>  x <= 0
+ *
+ * A = [[-1], [1]], b = [-1, 0], c = [1], k->l = 2.
+ */
+static const char *infeasible_lp(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;
+  const char *fail;
+
+  scs_float Ax[] = {-1.0, 1.0};
+  scs_int Ai[]   = {0, 1};
+  scs_int Ap[]   = {0, 2};
+
+  scs_float b[] = {-1.0, 0.0};
+  scs_float c[] = {1.0};
+
+  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->l = m;
+
+  scs_set_default_settings(stgs);
+  stgs->eps_abs = 1e-6;
+  stgs->eps_rel = 1e-6;
+  stgs->eps_infeas = 1e-9;
+
+  exitflag = scs(d, k, stgs, sol, &info);
+
+  mu_assert("infeasible_lp: expected SCS_INFEASIBLE",
+            exitflag == SCS_INFEASIBLE);
+  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;
+}

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

@@ -0,0 +1,75 @@
+#include "glbopts.h"
+#include "linalg.h"
+#include "minunit.h"
+#include "problem_utils.h"
+#include "scs.h"
+#include "util.h"
+
+/*
+ * Infeasible SOCP: (t, x) in SOC_2  AND  t <= -1.
+ * Since SOC_2 requires t >= |x| >= 0, t <= -1 is infeasible.
+ *
+ * Variables [t, x] (n=2), m=3.
+ * Cone order: l=1 first, then q=[2].
+ *   Row 0 (l=1):  t + s0 = -1, s0 >= 0  =>  t <= -1
+ *   Row 1 (q[0]): -t + s1 = 0  => s1 = t
+ *   Row 2 (q[1]): -x + s2 = 0  => s2 = x
+ *   => (t, x) in SOC_2 AND t <= -1: infeasible since SOC_2 requires t >= 0.
+ *
+ * A cols (CSC):
+ *   col 0 (t): row 0 -> +1, row 1 -> -1
+ *   col 1 (x): row 2 -> -1
+ */
+static const char *infeasible_socp(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;
+  const char *fail;
+
+  scs_float Ax[] = {1.0, -1.0, -1.0};
+  scs_int Ai[]   = {0, 1, 2};
+  scs_int Ap[]   = {0, 2, 3};
+
+  scs_float b[] = {-1.0, 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->l = 1;
+  k->qsize = 1;
+  k->q = q;
+
+  scs_set_default_settings(stgs);
+  stgs->eps_abs = 1e-6;
+  stgs->eps_rel = 1e-6;
+  stgs->eps_infeas = 1e-9;
+
+  exitflag = scs(d, k, stgs, sol, &info);
+
+  mu_assert("infeasible_socp: expected SCS_INFEASIBLE",
+            exitflag == SCS_INFEASIBLE);
+  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;
+}

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

@@ -0,0 +1,110 @@
+#include "glbopts.h"
+#include "linalg.h"
+#include "minunit.h"
+#include "problem_utils.h"
+#include "scs.h"
+#include "util.h"
+
+/*
+ * Test scs_update (b and/or c) for a simple LP.
+ *
+ * Base problem: min x  s.t.  x >= 2
+ *   row 0: -x + s = -2, s >= 0  =>  x >= 2
+ *   n=1, m=1, k->l=1
+ *   A=[[-1]], b=[-2], c=[1]
+ *   Optimal: x=2, obj=2.
+ *
+ * After scs_update(b=[-3]): x >= 3, obj=3.
+ * After scs_update(c=[2]):  min 2x s.t. x >= 3, obj=6.
+ * After scs_update(b=[-2], c=[1]): back to original, obj=2.
+ */
+static const char *lp_update(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_int success;
+  const char *fail;
+
+  scs_float Ax[] = {-1.0};
+  scs_int Ai[]   = {0};
+  scs_int Ap[]   = {0, 1};
+
+  scs_float b[] = {-2.0};
+  scs_float c[] = {1.0};
+
+  scs_int m = 1, 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->l = m;
+
+  scs_set_default_settings(stgs);
+  stgs->eps_abs = 1e-6;
+  stgs->eps_rel = 1e-6;
+
+  ScsWork *w = scs_init(d, k, stgs);
+  mu_assert("lp_update: scs_init returned NULL", w != SCS_NULL);
+
+  /* base solve: min x s.t. x >= 2, expected obj=2 */
+  exitflag = scs_solve(w, sol, &info, 0);
+  success = exitflag == SCS_SOLVED && ABS(info.pobj - 2.0) < 1e-4;
+  mu_assert("lp_update: base solve failed", success);
+  fail = verify_solution_correct(d, k, stgs, &info, sol, exitflag);
+  if (fail) return fail;
+
+  /* update b: x >= 3, expected obj=3 */
+  b[0] = -3.0;
+  scs_update(w, b, SCS_NULL);
+  exitflag = scs_solve(w, sol, &info, 1);
+  success = exitflag == SCS_SOLVED && ABS(info.pobj - 3.0) < 1e-4;
+  mu_assert("lp_update: b-update solve failed", success);
+  fail = verify_solution_correct(d, k, stgs, &info, sol, exitflag);
+  if (fail) return fail;
+
+  /* update c: min 2x s.t. x >= 3, expected obj=6 */
+  c[0] = 2.0;
+  scs_update(w, SCS_NULL, c);
+  exitflag = scs_solve(w, sol, &info, 1);
+  success = exitflag == SCS_SOLVED && ABS(info.pobj - 6.0) < 1e-4;
+  mu_assert("lp_update: c-update solve failed", success);
+  fail = verify_solution_correct(d, k, stgs, &info, sol, exitflag);
+  if (fail) return fail;
+
+  /* update both b and c back to original: min x s.t. x >= 2, expected obj=2 */
+  b[0] = -2.0;
+  c[0] = 1.0;
+  scs_update(w, b, c);
+  exitflag = scs_solve(w, sol, &info, 1);
+  success = exitflag == SCS_SOLVED && ABS(info.pobj - 2.0) < 1e-4;
+  mu_assert("lp_update: b+c-update solve failed", success);
+  fail = verify_solution_correct(d, k, stgs, &info, sol, exitflag);
+  if (fail) return fail;
+
+  /* null/null update: no change to problem, result must be identical */
+  scs_update(w, SCS_NULL, SCS_NULL);
+  exitflag = scs_solve(w, sol, &info, 1);
+  success = exitflag == SCS_SOLVED && ABS(info.pobj - 2.0) < 1e-4;
+  mu_assert("lp_update: null-null update changed result", success);
+  fail = verify_solution_correct(d, k, stgs, &info, sol, exitflag);
+
+  scs_finish(w);
+  SCS(free_sol)(sol);
+  scs_free(d->A);
+  scs_free(k);
+  scs_free(stgs);
+  scs_free(d);
+  return fail;
+}

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

@@ -173,8 +173,10 @@ static const char *qafiro_tiny_qp(void) {
   stgs->warm_start = 0;
   stgs->normalize = 0;
   stgs->adaptive_scale = 0;
-  stgs->acceleration_lookback = -10;
+  stgs->acceleration_lookback = 10;
   stgs->acceleration_interval = 10;
+  stgs->acceleration_type_1 = 0;
+  stgs->acceleration_regularization = 1e-12;
   stgs->log_csv_filename = "qafiro_tiny_qp.csv";
 
   exitflag = scs(d, k, stgs, sol, &info);

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

@@ -8,6 +8,7 @@
 #include "util.h"
 
 static const char *rob_gauss_cov_est(void) {
+  scs_int cold_iter;
   ScsCone *k = (ScsCone *)scs_calloc(1, sizeof(ScsCone));
   ScsData *d = (ScsData *)scs_calloc(1, sizeof(ScsData));
   ScsSettings *stgs = (ScsSettings *)scs_calloc(1, sizeof(ScsSettings));
@@ -163,6 +164,7 @@ static const char *rob_gauss_cov_est(void) {
   stgs->eps_infeas = 1e-9;
 
   exitflag = scs(d, k, stgs, sol, &info);
+  cold_iter = info.iter;
 
   perr = SCS(dot)(d->c, sol->x, d->n) - opt;
   derr = -SCS(dot)(d->b, sol->y, d->m) - opt;
@@ -178,11 +180,12 @@ static const char *rob_gauss_cov_est(void) {
   if (fail)
     return fail;
 
-  /* test warm-starting */
+  /* test warm-starting: relative to the cold solve, so the bound stays
+   * meaningful when the metric (and hence the iteration count) changes */
   stgs->warm_start = 1;
   exitflag = scs(d, k, stgs, sol, &info);
-  /* 100 iters should be enough if warm-started */
-  mu_assert("rob_gauss_cov_est: warm-start failure", info.iter <= 100);
+  mu_assert("rob_gauss_cov_est: warm-start failure",
+            info.iter <= cold_iter / 2);
   success = ABS(perr) < 1e-4 && ABS(derr) < 1e-4 && exitflag == SCS_SOLVED;
 
   mu_assert("rob_gauss_cov_est: SCS failed to produce outputflag SCS_SOLVED",

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

@@ -331,6 +331,11 @@ static const char *small_qp(void) {
   stgs->eps_abs = 1e-6;
   stgs->eps_rel = 1e-6;
   stgs->eps_infeas = 1e-10;
+  /* fixed metric for reproducible trajectories across platforms, matching
+   * the suite convention (adaptive dynamics have dedicated tests); with
+   * adaptive scaling on, this instance stalls on some architectures in
+   * the no-acceleration builds */
+  stgs->adaptive_scale = 0;
 
   ScsWork *w = scs_init(d, k, stgs);
   exitflag = scs_solve(w, sol, &info, 0);

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

@@ -0,0 +1,92 @@
+#include "glbopts.h"
+#include "linalg.h"
+#include "minunit.h"
+#include "problem_utils.h"
+#include "scs.h"
+#include "util.h"
+
+/*
+ * Test box cone projection on a simple LP (no P matrix).
+ *
+ * K_box = {(t, s) : bl_i * t <= s_i <= bu_i * t, t >= 0}
+ *
+ * Problem: minimize x1 + x2
+ *          subject to -1 <= x1 <= 1
+ *                     -2 <= x2 <= 2
+ * Solution: x1 = -1, x2 = -2, obj = -3.
+ *
+ * SCS formulation: Ax + s = b, s in K_box
+ *   k->bsize = 3  (t + x1 + x2)
+ *   k->bl = [-1, -2], k->bu = [1, 2]
+ *   Row 0 (t-slot):  0*x1 + 0*x2 + s[0] = 1  =>  t = 1
+ *   Row 1 (x1-slot): -x1 + s[1] = 0           =>  s[1] = x1
+ *   Row 2 (x2-slot): -x2 + s[2] = 0           =>  s[2] = x2
+ *
+ * A (CSC, 3x2):
+ *   col 0 (x1): row 1 -> -1
+ *   col 1 (x2): row 2 -> -1
+ */
+static const char *test_box_cone_lp(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.0;
+
+  scs_float Ax[] = {-1.0, -1.0};
+  scs_int Ai[]   = {1, 2};
+  scs_int Ap[]   = {0, 1, 2};
+
+  scs_float b[] = {1.0, 0.0, 0.0};
+  scs_float c[] = {1.0, 1.0};
+
+  scs_float bl[] = {-1.0, -2.0};
+  scs_float bu[] = {1.0, 2.0};
+
+  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->bsize = 3;
+  k->bl = bl;
+  k->bu = bu;
+
+  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_box_cone_lp: 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;
+}

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

@@ -0,0 +1,96 @@
+#include "glbopts.h"
+#include "linalg.h"
+#include "minunit.h"
+#include "problem_utils.h"
+#include "scs.h"
+#include "util.h"
+
+/*
+ * Dual exponential cone test.
+ *
+ * K_exp* (dual exp cone) = {(u,v,w): u<=0, -u*exp(v/u - 1) <= w}
+ *                        U {u=0, v>=0, w>=0}
+ * (Friberg 2021 convention used by SCS.)
+ *
+ * Problem: minimize w  s.t.  (u, v, w) in K_exp*,  u = -1,  v = 1.
+ *
+ * With u=-1, v=1 (first branch, u<0):
+ *   -(-1)*exp(1/(-1) - 1) = exp(-2) <= w
+ * Optimal: w* = exp(-2) ~= 0.13534, obj ~= 0.13534.
+ *
+ * Cone ordering: z=2 (equality rows 0-1), ed=1 (dual exp triple rows 2-4).
+ * Variables [u, v, w] (n=3), m=5.
+ *
+ * Constraints:
+ *   Row 0 (z): u = -1  -> A[0,0]=1, b[0]=-1
+ *   Row 1 (z): v =  1  -> A[1,1]=1, b[1]= 1
+ *   Row 2 (ed): s[2] = u  -> A[2,0]=-1, b[2]=0
+ *   Row 3 (ed): s[3] = v  -> A[3,1]=-1, b[3]=0
+ *   Row 4 (ed): s[4] = w  -> A[4,2]=-1, b[4]=0
+ *
+ * A cols (CSC):
+ *   col 0 (u): row 0 -> +1, row 2 -> -1
+ *   col 1 (v): row 1 -> +1, row 3 -> -1
+ *   col 2 (w): row 4 -> -1
+ */
+static const char *test_dual_exp_cone(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;
+
+  /* exp(-2) = 0.13533528323661270... */
+  scs_float opt = 0.13533528323661270;
+
+  scs_float Ax[] = {1.0, -1.0, 1.0, -1.0, -1.0};
+  scs_int Ai[] = {0, 2, 1, 3, 4};
+  scs_int Ap[] = {0, 2, 4, 5};
+
+  scs_float b[] = {-1.0, 1.0, 0.0, 0.0, 0.0};
+  scs_float c[] = {0.0, 0.0, 1.0};
+
+  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->ed = 1;
+
+  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_dual_exp_cone: 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;
+}