scs 0.5.6 → 0.6.0

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

@@ -0,0 +1,212 @@
+#include "glbopts.h"
+#include "minunit.h"
+#include "scs.h"
+#include "util.h"
+
+/*
+ * Shared tiny LP used for all inaccurate termination tests.
+ * min x  s.t.  x >= 2
+ * n=1, m=1, l=1, A=[[-1]], b=[-2], c=[1], optimal obj=2.
+ */
+#define _INACCURATE_LP_VARS                                                    \
+  scs_float Ax[] = {-1.0};                                                     \
+  scs_int Ai[] = {0};                                                          \
+  scs_int Ap[] = {0, 1};                                                       \
+  scs_float b_feas[] = {-2.0};                                                 \
+  scs_float c_feas[] = {1.0}
+
+/*
+ * Shared tiny infeasible LP.
+ * x >= 1  AND  x <= 0 (infeasible).
+ * n=1, m=2, l=2, A=[[-1],[1]], b=[-1,0], c=[1]
+ */
+#define _INACCURATE_INFEAS_VARS                                                \
+  scs_float Ax_i[] = {-1.0, 1.0};                                              \
+  scs_int Ai_i[] = {0, 1};                                                     \
+  scs_int Ap_i[] = {0, 2};                                                     \
+  scs_float b_i[] = {-1.0, 0.0};                                               \
+  scs_float c_i[] = {1.0}
+
+/*
+ * Shared tiny unbounded LP.
+ * min -x  s.t.  x >= 0  (unbounded below).
+ * n=1, m=1, l=1, A=[[-1]], b=[0], c=[-1]
+ */
+#define _INACCURATE_UNBDD_VARS                                                 \
+  scs_float Ax_u[] = {-1.0};                                                   \
+  scs_int Ai_u[] = {0};                                                        \
+  scs_int Ap_u[] = {0, 1};                                                     \
+  scs_float b_u[] = {0.0};                                                     \
+  scs_float c_u[] = {-1.0}
+
+/*
+ * Test SCS_SOLVED_INACCURATE: run a feasible, bounded LP with max_iters=2.
+ * After only 2 iterations tau > 0 and kap/tau is small, so set_unfinished
+ * returns SCS_SOLVED_INACCURATE.
+ */
+static const char *test_solved_inaccurate(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;
+  _INACCURATE_LP_VARS;
+  scs_int m = 1, n = 1;
+
+  d->m = m; d->n = n; d->b = b_feas; d->c = c_feas;
+  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;
+
+  scs_set_default_settings(stgs);
+  stgs->max_iters = 2;
+  stgs->verbose = 1;
+
+  exitflag = scs(d, k, stgs, sol, &info);
+
+  mu_assert("test_solved_inaccurate: expected SCS_SOLVED_INACCURATE",
+            exitflag == SCS_SOLVED_INACCURATE);
+  mu_assert("test_solved_inaccurate: expected max_iters exhausted",
+            info.iter == stgs->max_iters);
+
+  SCS(free_sol)(sol);
+  scs_free(d->A);
+  scs_free(k);
+  scs_free(stgs);
+  scs_free(d);
+  return 0;
+}
+
+/*
+ * Test SCS_INFEASIBLE_INACCURATE: run an infeasible LP with eps_infeas=0
+ * (disables the infeasibility termination criterion entirely), so the solver
+ * runs until max_iters.  set_unfinished then detects kap > tau with the
+ * infeasibility direction (bty_tau < 0) and returns SCS_INFEASIBLE_INACCURATE.
+ */
+static const char *test_infeasible_inaccurate(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;
+  _INACCURATE_INFEAS_VARS;
+  scs_int m = 2, n = 1;
+
+  d->m = m; d->n = n; d->b = b_i; d->c = c_i;
+  d->A = (ScsMatrix *)scs_calloc(1, sizeof(ScsMatrix));
+  d->A->m = m; d->A->n = n;
+  d->A->x = Ax_i; d->A->i = Ai_i; d->A->p = Ap_i;
+  k->l = 2;
+
+  scs_set_default_settings(stgs);
+  stgs->eps_infeas = 0.0; /* disabled: res < 0 never true, forces max_iters */
+  /* Use enough iterations so kap >> tau is clearly established across all
+   * linear solver backends (numerical trajectory is backend-dependent). */
+  stgs->max_iters = 100;
+  stgs->verbose = 1;
+
+  exitflag = scs(d, k, stgs, sol, &info);
+
+  mu_assert("test_infeasible_inaccurate: expected SCS_INFEASIBLE_INACCURATE",
+            exitflag == SCS_INFEASIBLE_INACCURATE);
+  mu_assert("test_infeasible_inaccurate: expected max_iters exhausted",
+            info.iter == stgs->max_iters);
+
+  SCS(free_sol)(sol);
+  scs_free(d->A);
+  scs_free(k);
+  scs_free(stgs);
+  scs_free(d);
+  return 0;
+}
+
+/*
+ * Test SCS_UNBOUNDED_INACCURATE: run an unbounded LP with eps_infeas=0
+ * (disables the unboundedness termination criterion entirely), so the solver
+ * runs until max_iters.  set_unfinished then detects kap > tau with the
+ * unboundedness direction (ctx_tau < 0) and returns SCS_UNBOUNDED_INACCURATE.
+ */
+static const char *test_unbounded_inaccurate(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;
+  _INACCURATE_UNBDD_VARS;
+  scs_int m = 1, n = 1;
+
+  d->m = m; d->n = n; d->b = b_u; d->c = c_u;
+  d->A = (ScsMatrix *)scs_calloc(1, sizeof(ScsMatrix));
+  d->A->m = m; d->A->n = n;
+  d->A->x = Ax_u; d->A->i = Ai_u; d->A->p = Ap_u;
+  k->l = 1;
+
+  scs_set_default_settings(stgs);
+  stgs->eps_infeas = 0.0; /* disabled: res < 0 never true, forces max_iters */
+  /* Use enough iterations so kap >> tau is clearly established across all
+   * linear solver backends (numerical trajectory is backend-dependent). */
+  stgs->max_iters = 100;
+  stgs->verbose = 1;
+
+  exitflag = scs(d, k, stgs, sol, &info);
+
+  mu_assert("test_unbounded_inaccurate: expected SCS_UNBOUNDED_INACCURATE",
+            exitflag == SCS_UNBOUNDED_INACCURATE);
+  mu_assert("test_unbounded_inaccurate: expected max_iters exhausted",
+            info.iter == stgs->max_iters);
+
+  SCS(free_sol)(sol);
+  scs_free(d->A);
+  scs_free(k);
+  scs_free(stgs);
+  scs_free(d);
+  return 0;
+}
+
+/*
+ * Test SCS_SOLVED_INACCURATE with max_iters=1: the solver exits after a single
+ * iteration with tau > 0 (kap/tau small), so set_unfinished returns
+ * SCS_SOLVED_INACCURATE.  This exercises the minimum-iteration code path.
+ */
+static const char *test_max_iters_1(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;
+  _INACCURATE_LP_VARS;
+  scs_int m = 1, n = 1;
+
+  d->m = m; d->n = n; d->b = b_feas; d->c = c_feas;
+  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;
+
+  scs_set_default_settings(stgs);
+  stgs->max_iters = 1;
+  stgs->verbose = 1;
+
+  exitflag = scs(d, k, stgs, sol, &info);
+
+  mu_assert("test_max_iters_1: expected SCS_SOLVED_INACCURATE",
+            exitflag == SCS_SOLVED_INACCURATE);
+  mu_assert("test_max_iters_1: expected exactly 1 iteration",
+            info.iter == 1);
+
+  SCS(free_sol)(sol);
+  scs_free(d->A);
+  scs_free(k);
+  scs_free(stgs);
+  scs_free(d);
+  return 0;
+}
+
+#undef _INACCURATE_LP_VARS
+#undef _INACCURATE_INFEAS_VARS
+#undef _INACCURATE_UNBDD_VARS

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

@@ -0,0 +1,113 @@
+#include "glbopts.h"
+#include "linalg.h"
+#include "minunit.h"
+#include "problem_utils.h"
+#include "scs.h"
+#include "util.h"
+
+/*
+ * Mixed-cone test: exercises the full cone ordering path (z, l, q, ep)
+ * in a single problem to verify that set_cone_boundaries and proj_cone
+ * dispatch correctly across multiple different cone types.
+ *
+ * Problem (5 variables, 8 constraints):
+ *   minimize  x1 + x2 + x3 + x4 + x5
+ *   subject to
+ *     x1 + x2 = 3                (zero cone, 1 row)
+ *     x3 >= 1                    (non-neg cone, 1 row)
+ *     (x4, x5) in SOC_2          (SOC, 2 rows)
+ *     (x1, x2, x3) in K_exp      (exp cone, 3 rows)
+ *     x4 >= 1   (duplicate of above, extra l row)
+ *
+ * Cone ordering: z=1, l=2, q=[2], ep=1 → total m=1+2+2+3=8.
+ *
+ * But this is over-constrained. Let me use a simpler formulation:
+ *
+ * Variables: [x1, x2, x3] (n=3)
+ * m=6, cone order: z=1, l=1, q=[2], ep=0 (skipping exp for simpler math)
+ *
+ * Actually let's just use z + l + q:
+ *   minimize  x1 + x2 + x3
+ *   subject to
+ *     x1 = 2                        (zero cone, 1 row: z=1)
+ *     x2 >= 1                       (non-neg cone, 1 row: l=1)
+ *     (x3, x2) in SOC_2             (SOC, 2 rows: q=[2])
+ *   Optimal: x1=2, and (x3, x2) in SOC means x3 >= |x2|.
+ *   To minimize x2+x3 with x2>=1: x2=1, x3>=1, so x3=1.
+ *   obj = 2+1+1 = 4.
+ *
+ * SCS formulation: Ax + s = b, s in K
+ *   Row 0 (z):  -x1 + s0 = -2       => x1 = 2
+ *   Row 1 (l):  -x2 + s1 = -1       => x2 >= 1
+ *   Row 2 (q0): -x3 + s2 = 0        => s2 = x3  (t component of SOC)
+ *   Row 3 (q1): -x2 + s3 = 0        => s3 = x2  (body of SOC)
+ *   SOC: |s3| <= s2, i.e., |x2| <= x3
+ *
+ * A (4x3 CSC):
+ *   col 0 (x1): row 0 -> -1
+ *   col 1 (x2): row 1 -> -1, row 3 -> -1
+ *   col 2 (x3): row 2 -> -1
+ */
+static const char *test_mixed_cones(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 = 4.0;
+
+  scs_float Ax[] = {-1.0, -1.0, -1.0, -1.0};
+  scs_int Ai[]   = {0, 1, 3, 2};
+  scs_int Ap[]   = {0, 1, 3, 4};
+
+  scs_float b[] = {-2.0, -1.0, 0.0, 0.0};
+  scs_float c[] = {1.0, 1.0, 1.0};
+
+  scs_int q_arr[] = {2};
+  scs_int m = 4, 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 = 1;
+  k->l = 1;
+  k->qsize = 1;
+  k->q = q_arr;
+
+  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_mixed_cones: 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_normalize_roundtrip.h

@@ -0,0 +1,279 @@
+#include "glbopts.h"
+#include "linalg.h"
+#include "minunit.h"
+#include "problem_utils.h"
+#include "scs.h"
+#include "util.h"
+
+/*
+ * Test that normalization is consistent:
+ * 1. Solve the same problem with normalize=0 and normalize=1 and verify
+ *    that the returned (un-normalized) solutions agree.
+ * 2. Solve a problem where A entries span several orders of magnitude to
+ *    exercise the Ruiz equilibration more aggressively.
+ *
+ * Problem (LP):
+ *   minimize    x1 + x2 + x3
+ *   subject to  x1 >= 1     (l cone)
+ *               x2 >= 10    (l cone)
+ *               x3 >= 100   (l cone)
+ *   A entries: -1, -1, -1 (diagonal), b = [-1, -10, -100]
+ *   Optimal: x = [1, 10, 100], obj = 111.
+ *
+ * The varying magnitudes in b (and correspondingly in optimal x) ensure
+ * that D scaling factors are non-trivial.
+ */
+static const char *test_normalize_roundtrip_lp(void) {
+  ScsCone *k0, *k1;
+  ScsData *d0, *d1;
+  ScsSettings *stgs0, *stgs1;
+  ScsSolution *sol0, *sol1;
+  ScsInfo info0 = {0}, info1 = {0};
+  scs_int exitflag0, exitflag1;
+  scs_float err_x, err_y, err_s, err_obj;
+  scs_int i;
+
+  scs_float opt = 111.0;
+
+  scs_int Ai[]   = {0, 1, 2};
+  scs_int Ap[]   = {0, 1, 2, 3};
+  scs_int m = 3, n = 3;
+
+  /* Separate copies needed because normalization modifies A, b, c in place */
+  scs_float Ax0[] = {-1.0, -1.0, -1.0};
+  scs_float Ax1[] = {-1.0, -1.0, -1.0};
+  scs_float b0[]  = {-1.0, -10.0, -100.0};
+  scs_float b1[]  = {-1.0, -10.0, -100.0};
+  scs_float c0[]  = {1.0, 1.0, 1.0};
+  scs_float c1[]  = {1.0, 1.0, 1.0};
+
+  /* --- Setup problem 0: normalize OFF --- */
+  k0 = (ScsCone *)scs_calloc(1, sizeof(ScsCone));
+  d0 = (ScsData *)scs_calloc(1, sizeof(ScsData));
+  stgs0 = (ScsSettings *)scs_calloc(1, sizeof(ScsSettings));
+  sol0 = (ScsSolution *)scs_calloc(1, sizeof(ScsSolution));
+
+  d0->m = m; d0->n = n;
+  d0->b = b0; d0->c = c0;
+  d0->A = (ScsMatrix *)scs_calloc(1, sizeof(ScsMatrix));
+  d0->A->m = m; d0->A->n = n;
+  d0->A->x = Ax0; d0->A->i = Ai; d0->A->p = Ap;
+  k0->l = m;
+  scs_set_default_settings(stgs0);
+  stgs0->normalize = 0;
+  stgs0->eps_abs = 1e-9;
+  stgs0->eps_rel = 1e-9;
+
+  /* --- Setup problem 1: normalize ON --- */
+  k1 = (ScsCone *)scs_calloc(1, sizeof(ScsCone));
+  d1 = (ScsData *)scs_calloc(1, sizeof(ScsData));
+  stgs1 = (ScsSettings *)scs_calloc(1, sizeof(ScsSettings));
+  sol1 = (ScsSolution *)scs_calloc(1, sizeof(ScsSolution));
+
+  d1->m = m; d1->n = n;
+  d1->b = b1; d1->c = c1;
+  d1->A = (ScsMatrix *)scs_calloc(1, sizeof(ScsMatrix));
+  d1->A->m = m; d1->A->n = n;
+  d1->A->x = Ax1; d1->A->i = Ai; d1->A->p = Ap;
+  k1->l = m;
+  scs_set_default_settings(stgs1);
+  stgs1->normalize = 1;
+  stgs1->eps_abs = 1e-9;
+  stgs1->eps_rel = 1e-9;
+
+  /* --- Solve both --- */
+  exitflag0 = scs(d0, k0, stgs0, sol0, &info0);
+  exitflag1 = scs(d1, k1, stgs1, sol1, &info1);
+
+  mu_assert("normalize_roundtrip: unnormalized solve failed",
+            exitflag0 == SCS_SOLVED);
+  mu_assert("normalize_roundtrip: normalized solve failed",
+            exitflag1 == SCS_SOLVED);
+
+  /* Both should match the known optimal */
+  mu_assert("normalize_roundtrip: unnormalized obj wrong",
+            ABS(info0.pobj - opt) < 1e-4);
+  mu_assert("normalize_roundtrip: normalized obj wrong",
+            ABS(info1.pobj - opt) < 1e-4);
+
+  /* Solutions should agree (un-normalization must be correct) */
+  err_x = 0; err_y = 0; err_s = 0;
+  for (i = 0; i < n; ++i) {
+    scs_float d = ABS(sol0->x[i] - sol1->x[i]);
+    if (d > err_x) err_x = d;
+  }
+  for (i = 0; i < m; ++i) {
+    scs_float dy = ABS(sol0->y[i] - sol1->y[i]);
+    scs_float ds = ABS(sol0->s[i] - sol1->s[i]);
+    if (dy > err_y) err_y = dy;
+    if (ds > err_s) err_s = ds;
+  }
+  err_obj = ABS(info0.pobj - info1.pobj);
+
+  scs_printf("normalize_roundtrip: x_err=%.2e y_err=%.2e s_err=%.2e "
+             "obj_err=%.2e\n", err_x, err_y, err_s, err_obj);
+
+  mu_assert("normalize_roundtrip: x vectors differ too much", err_x < 1e-4);
+  mu_assert("normalize_roundtrip: y vectors differ too much", err_y < 1e-4);
+  mu_assert("normalize_roundtrip: s vectors differ too much", err_s < 1e-4);
+  mu_assert("normalize_roundtrip: obj values differ too much", err_obj < 1e-5);
+
+  /* Cleanup */
+  SCS(free_sol)(sol0);
+  scs_free(d0->A);
+  scs_free(k0);
+  scs_free(stgs0);
+  scs_free(d0);
+
+  SCS(free_sol)(sol1);
+  scs_free(d1->A);
+  scs_free(k1);
+  scs_free(stgs1);
+  scs_free(d1);
+
+  return 0;
+}
+
+/*
+ * Test normalization roundtrip with a QP where P is present,
+ * ensuring the E scaling (column scaling for P) is also correct.
+ *
+ * Problem (QP):
+ *   minimize    0.5 * (x1^2 + 100*x2^2) + x1 + x2
+ *   subject to  x1 >= 0, x2 >= 0
+ *
+ * P = [[1, 0], [0, 100]]  (upper triangular)
+ * c = [1, 1]
+ * A = [[-1, 0], [0, -1]], b = [0, 0], l = 2
+ *
+ * The 100x difference in P eigenvalues stresses normalization.
+ * Optimal: x1 = 0 (since the unconstrained min of x1 + 0.5*x1^2 is at
+ *          x1 = -1 which is infeasible), x2 = 0 (unconstrained min at
+ *          x2 = -0.01 which is infeasible).
+ * Actually: x1 >= 0 binds, x2 >= 0 binds => x = [0, 0], obj = 0.
+ *
+ * Wait, let me redo: min 0.5*x'Px + c'x s.t. x >= 0.
+ * Gradient at x=0: c = [1, 1] > 0, so x=0 is optimal. obj=0.
+ */
+static const char *test_normalize_roundtrip_qp(void) {
+  ScsCone *k0, *k1;
+  ScsData *d0, *d1;
+  ScsSettings *stgs0, *stgs1;
+  ScsSolution *sol0, *sol1;
+  ScsInfo info0 = {0}, info1 = {0};
+  scs_int exitflag0, exitflag1;
+  scs_float err_x, err_y, err_s, err_obj;
+  scs_int i;
+
+  scs_float opt = 0.0;
+
+  /* A (2x2 diagonal) */
+  scs_float Ax0[] = {-1.0, -1.0};
+  scs_float Ax1[] = {-1.0, -1.0};
+  scs_int Ai[]    = {0, 1};
+  scs_int Ap[]    = {0, 1, 2};
+
+  /* P (2x2 upper triangular, diagonal: [1, 100]) */
+  scs_float Px0[] = {1.0, 100.0};
+  scs_float Px1[] = {1.0, 100.0};
+  scs_int Pi[]    = {0, 1};
+  scs_int Pp[]    = {0, 1, 2};
+
+  scs_float b0[] = {0.0, 0.0};
+  scs_float b1[] = {0.0, 0.0};
+  scs_float c0[] = {1.0, 1.0};
+  scs_float c1[] = {1.0, 1.0};
+  scs_int m = 2, n = 2;
+
+  /* --- normalize OFF --- */
+  k0 = (ScsCone *)scs_calloc(1, sizeof(ScsCone));
+  d0 = (ScsData *)scs_calloc(1, sizeof(ScsData));
+  stgs0 = (ScsSettings *)scs_calloc(1, sizeof(ScsSettings));
+  sol0 = (ScsSolution *)scs_calloc(1, sizeof(ScsSolution));
+
+  d0->m = m; d0->n = n;
+  d0->b = b0; d0->c = c0;
+  d0->A = (ScsMatrix *)scs_calloc(1, sizeof(ScsMatrix));
+  d0->A->m = m; d0->A->n = n;
+  d0->A->x = Ax0; d0->A->i = Ai; d0->A->p = Ap;
+  d0->P = (ScsMatrix *)scs_calloc(1, sizeof(ScsMatrix));
+  d0->P->m = n; d0->P->n = n;
+  d0->P->x = Px0; d0->P->i = Pi; d0->P->p = Pp;
+  k0->l = m;
+  scs_set_default_settings(stgs0);
+  stgs0->normalize = 0;
+  stgs0->eps_abs = 1e-9;
+  stgs0->eps_rel = 1e-9;
+
+  /* --- normalize ON --- */
+  k1 = (ScsCone *)scs_calloc(1, sizeof(ScsCone));
+  d1 = (ScsData *)scs_calloc(1, sizeof(ScsData));
+  stgs1 = (ScsSettings *)scs_calloc(1, sizeof(ScsSettings));
+  sol1 = (ScsSolution *)scs_calloc(1, sizeof(ScsSolution));
+
+  d1->m = m; d1->n = n;
+  d1->b = b1; d1->c = c1;
+  d1->A = (ScsMatrix *)scs_calloc(1, sizeof(ScsMatrix));
+  d1->A->m = m; d1->A->n = n;
+  d1->A->x = Ax1; d1->A->i = Ai; d1->A->p = Ap;
+  d1->P = (ScsMatrix *)scs_calloc(1, sizeof(ScsMatrix));
+  d1->P->m = n; d1->P->n = n;
+  d1->P->x = Px1; d1->P->i = Pi; d1->P->p = Pp;
+  k1->l = m;
+  scs_set_default_settings(stgs1);
+  stgs1->normalize = 1;
+  stgs1->eps_abs = 1e-9;
+  stgs1->eps_rel = 1e-9;
+
+  /* --- Solve both --- */
+  exitflag0 = scs(d0, k0, stgs0, sol0, &info0);
+  exitflag1 = scs(d1, k1, stgs1, sol1, &info1);
+
+  mu_assert("normalize_qp: unnormalized solve failed",
+            exitflag0 == SCS_SOLVED);
+  mu_assert("normalize_qp: normalized solve failed",
+            exitflag1 == SCS_SOLVED);
+
+  mu_assert("normalize_qp: unnormalized obj wrong",
+            ABS(info0.pobj - opt) < 1e-4);
+  mu_assert("normalize_qp: normalized obj wrong",
+            ABS(info1.pobj - opt) < 1e-4);
+
+  err_x = 0; err_y = 0; err_s = 0;
+  for (i = 0; i < n; ++i) {
+    scs_float d = ABS(sol0->x[i] - sol1->x[i]);
+    if (d > err_x) err_x = d;
+  }
+  for (i = 0; i < m; ++i) {
+    scs_float dy = ABS(sol0->y[i] - sol1->y[i]);
+    scs_float ds = ABS(sol0->s[i] - sol1->s[i]);
+    if (dy > err_y) err_y = dy;
+    if (ds > err_s) err_s = ds;
+  }
+  err_obj = ABS(info0.pobj - info1.pobj);
+
+  scs_printf("normalize_qp: x_err=%.2e y_err=%.2e s_err=%.2e "
+             "obj_err=%.2e\n", err_x, err_y, err_s, err_obj);
+
+  mu_assert("normalize_qp: x vectors differ too much", err_x < 1e-4);
+  mu_assert("normalize_qp: y vectors differ too much", err_y < 1e-4);
+  mu_assert("normalize_qp: s vectors differ too much", err_s < 1e-4);
+  mu_assert("normalize_qp: obj values differ too much", err_obj < 1e-5);
+
+  /* Cleanup */
+  SCS(free_sol)(sol0);
+  scs_free(d0->A);
+  scs_free(d0->P);
+  scs_free(k0);
+  scs_free(stgs0);
+  scs_free(d0);
+
+  SCS(free_sol)(sol1);
+  scs_free(d1->A);
+  scs_free(d1->P);
+  scs_free(k1);
+  scs_free(stgs1);
+  scs_free(d1);
+
+  return 0;
+}