scs 0.2.2 → 0.3.2

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

@@ -0,0 +1,124 @@
+#include "glbopts.h"
+#include "linalg.h"
+#include "minunit.h"
+#include "scs.h"
+#include "scs_matrix.h"
+#include "util.h"
+
+static const char *hs21_tiny_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));
+  ScsInfo info = {0};
+  scs_int exitflag;
+  scs_float perr, derr;
+  scs_int success;
+  const char *fail;
+
+  /* data */
+  scs_float Ax[] = {-10., -1., 1., -1.};
+  scs_int Ai[] = {1, 2, 1, 3};
+  scs_int Ap[] = {0, 2, 4};
+
+  scs_float Px[] = {0.02, 2.};
+  scs_int Pi[] = {0, 1};
+  scs_int Pp[] = {0, 1, 2};
+
+  scs_float b[] = {1., 0., 0., 0.};
+  scs_float c[] = {0., 0.};
+
+  scs_int m = 4;
+  scs_int n = 2;
+
+  scs_float bl[] = {10.0, 2.0, -50.0};
+  scs_float bu[] = {1e+20, 50.0, 50.0};
+  scs_int bsize = 4;
+
+  scs_float opt = 0.04000000000000625;
+  /* end data */
+
+  d->m = m;
+  d->n = n;
+  d->b = b;
+  d->c = c;
+
+  d->A = (ScsMatrix *)scs_calloc(1, sizeof(ScsMatrix));
+  d->P = (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;
+
+  d->P->m = n;
+  d->P->n = n;
+
+  d->P->x = Px;
+  d->P->i = Pi;
+  d->P->p = Pp;
+
+  k->bsize = bsize;
+  k->bl = bl;
+  k->bu = bu;
+
+  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);
+
+  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("hs21_tiny_qp: SCS failed to produce outputflag SCS_SOLVED",
+            success);
+  fail = verify_solution_correct(d, k, stgs, &info, sol, exitflag);
+
+  /* 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);
+  success = ABS(perr) < 1e-4 && ABS(derr) < 1e-4 && exitflag == SCS_SOLVED;
+
+  mu_assert("hs21_tiny_qp: SCS failed to produce outputflag SCS_SOLVED",
+            success);
+
+  /* test other settings */
+  stgs->warm_start = 0;
+  stgs->normalize = 0;
+  stgs->adaptive_scale = 0;
+  stgs->acceleration_lookback = 10;
+  stgs->acceleration_interval = 10;
+  stgs->log_csv_filename = "hs21_tiny_qp.csv";
+
+  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("hs21_tiny_qp: SCS failed to produce outputflag SCS_SOLVED",
+            success);
+
+  SCS(free_sol)(sol);
+  scs_free(d->A);
+  scs_free(d->P);
+  scs_free(k);
+  scs_free(stgs);
+  scs_free(d);
+  return fail;
+}

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

@@ -0,0 +1,116 @@
+#include "glbopts.h"
+#include "linalg.h"
+#include "minunit.h"
+#include "rw.h"
+#include "scs.h"
+#include "scs_matrix.h"
+#include "util.h"
+
+/* test read / write logic */
+static const char *hs21_tiny_qp_rw(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;
+
+  /* data */
+  scs_float Ax[] = {-10., -1., 1., -1.};
+  scs_int Ai[] = {1, 2, 1, 3};
+  scs_int Ap[] = {0, 2, 4};
+
+  scs_float Px[] = {0.02, 2.};
+  scs_int Pi[] = {0, 1};
+  scs_int Pp[] = {0, 1, 2};
+
+  scs_float b[] = {1., 0., 0., 0.};
+  scs_float c[] = {0., 0.};
+
+  scs_int m = 4;
+  scs_int n = 2;
+
+  scs_float bl[] = {10.0, 2.0, -50.0};
+  scs_float bu[] = {1e+20, 50.0, 50.0};
+  scs_int bsize = 4;
+
+  scs_float opt = 0.04000000000000625;
+  /* end data */
+
+  d->m = m;
+  d->n = n;
+  d->b = b;
+  d->c = c;
+
+  d->A = (ScsMatrix *)scs_calloc(1, sizeof(ScsMatrix));
+  d->P = (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;
+
+  d->P->m = n;
+  d->P->n = n;
+
+  d->P->x = Px;
+  d->P->i = Pi;
+  d->P->p = Pp;
+
+  k->bsize = bsize;
+  k->bl = bl;
+  k->bu = bu;
+
+  scs_set_default_settings(stgs);
+  stgs->eps_abs = 1e-6;
+  stgs->eps_rel = 1e-6;
+  stgs->eps_infeas = 1e-9;
+
+  stgs->write_data_filename = "hs21_tiny_qp";
+  stgs->max_iters = 1;
+
+  exitflag = scs(d, k, stgs, sol, &info);
+
+  /* kill the data */
+  scs_free(d->A);
+  scs_free(d->P);
+  scs_free(k);
+  scs_free(stgs);
+  scs_free(d);
+
+  SCS(read_data)("hs21_tiny_qp", &d, &k, &stgs);
+  stgs->max_iters = 1000;
+  /* solve with read data */
+  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("hs21_tiny_qp: SCS failed to produce outputflag SCS_SOLVED",
+            success);
+  fail = verify_solution_correct(d, k, stgs, &info, sol, exitflag);
+
+  /* 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);
+  success = ABS(perr) < 1e-4 && ABS(derr) < 1e-4 && exitflag == SCS_SOLVED;
+
+  mu_assert("hs21_tiny_qp: SCS failed to produce outputflag SCS_SOLVED",
+            success);
+
+  SCS(free_sol)(sol);
+  SCS(free_data)(d, k, stgs);
+  return fail;
+}

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

@@ -0,0 +1,100 @@
+#include "glbopts.h"
+#include "linalg.h"
+#include "minunit.h"
+#include "scs.h"
+#include "scs_matrix.h"
+#include "util.h"
+
+static const char *infeasible_tiny_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));
+  ScsInfo info = {0};
+  scs_int exitflag;
+  const char *fail;
+
+  /* data */
+  scs_float Ax[] = {
+      4.51689976e-01,  3.06592046e-03,  5.17304192e-01,  -3.03038477e+00,
+      -1.40509892e+00, 7.94277342e-04,  2.39454841e+00,  -7.60957360e-01,
+      -1.18946302e+00, 3.98797701e-01,  1.01386914e+00,  -2.53921734e+00,
+      -3.21202445e-01, 9.25735134e-01,  -2.54046934e-01, 1.28211442e-01,
+      -1.65155072e-01, -4.53308401e-01, -4.66709068e-01, -2.24298562e-01,
+      -4.92029627e-01, 8.05750411e-01,  -1.72920210e+00, -1.45633836e-01,
+      6.39086786e-01,  1.20509649e-01,  4.19672104e-01,  -2.29274817e-01,
+      3.30125838e-01,  4.12874191e-01,  1.05357823e+00,  2.10587878e+00,
+      5.54934230e-01,  2.42617608e+00,  -8.33596918e-01, -6.83444334e-01,
+      8.23856780e-01,  -4.14240741e-01, -7.24051659e-01, 1.06144329e-01,
+      6.92857027e-01,  1.64822980e+00,  1.94603528e-01,  -7.58318366e-01,
+      1.42948833e+00,  -2.49039902e-01, 2.15319490e-01,  -1.52651434e+00,
+      -3.94761305e-01, -5.24305949e-01};
+  scs_int Ai[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6,
+                  7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3,
+                  4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+  scs_int Ap[] = {0, 10, 20, 30, 40, 50};
+
+  scs_float Px[] = {0.40113649, 0.15897142, 0.37369516,  -0.05899464,
+                    0.0772996,  0.37333677, -0.02994108, 0.04870077,
+                    0.32221413, 0.28665235, -0.27383424, 0.04842465,
+                    0.07832219, 0.0660133,  0.49993284};
+  scs_int Pi[] = {0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4};
+  scs_int Pp[] = {0, 1, 3, 6, 10, 15};
+
+  scs_float b[] = {-0.057279,   0.10451534, -0.10459346, -0.18452294,
+                   0.18609658,  0.15795524, -0.00562746, -0.85852899,
+                   -0.48271335, 0.61951655};
+  scs_float c[] = {-0.16566256, -1.33116808, -0.1767858, -1.0940148,
+                   1.15348983};
+
+  scs_int m = 10;
+  scs_int n = 5;
+
+  scs_int l = m;
+
+  /* end data */
+
+  d->m = m;
+  d->n = n;
+  d->b = b;
+  d->c = c;
+
+  d->A = (ScsMatrix *)scs_calloc(1, sizeof(ScsMatrix));
+  d->P = (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;
+
+  d->P->m = n;
+  d->P->n = n;
+
+  d->P->x = Px;
+  d->P->i = Pi;
+  d->P->p = Pp;
+
+  k->l = l;
+
+  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_tiny_qp: SCS failed to produce outputflag 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(d->P);
+  scs_free(k);
+  scs_free(stgs);
+  scs_free(d);
+  return fail;
+}

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

@@ -0,0 +1,199 @@
+#include "glbopts.h"
+#include "linalg.h"
+#include "minunit.h"
+#include "scs.h"
+#include "scs_matrix.h"
+#include "util.h"
+
+static const char *qafiro_tiny_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));
+  ScsInfo info = {0};
+  scs_int exitflag;
+  scs_float perr, derr;
+  scs_int success;
+  const char *fail;
+
+  /* data */
+  scs_float Ax[] = {
+      -1.,    -1.06, -1.,    -0.301, -1.,    1.,     1.,     -1.,   1.,
+      1.,     -1.,   1.,     -1.,    -1.,    -1.,    -1.06,  -1.,   -0.301,
+      -1.,    -1.,   -1.06,  -1.,    -0.313, -1.,    -1.,    -0.96, -1.,
+      -0.313, -1.,   -1.,    -0.86,  -1.,    -0.326, -1.,    1.,    -2.364,
+      -1.,    1.,    -2.386, -1.,    1.,     -2.408, -1.,    1.,    -2.429,
+      -1.,    1.,    -1.4,   -1.,    1.,     1.,     -1.,    1.,    -1.,
+      -1.,    -0.43, -1.,    -1.,    -0.109, -1.,    1.,     1.,    -1.,
+      1.,     1.,    -1.,    1.,     1.,     -1.,    1.,     -1.,   -1.,
+      1.,     -0.43, -1.,    -0.109, -1.,    1.,     -0.43,  -1.,   -0.108,
+      -1.,    1.,    -0.39,  -1.,    -0.108, -1.,    1.,     -0.37, -1.,
+      -0.107, -1.,   1.,     -2.191, -1.,    1.,     -2.219, -1.,   1.,
+      -2.249, -1.,   1.,     -2.279, -1.,    -1.,    -1.4,   -1.,   1.,
+      1.,     -1.,   1.,     -1.,    -1.,    1.,     -1.};
+  scs_int Ai[] = {0,  1,  16, 24, 28, 0,  15, 29, 0,  22, 30, 1,  26, 31, 4,
+                  5,  12, 25, 32, 4,  5,  11, 25, 33, 4,  5,  9,  25, 34, 4,
+                  5,  10, 25, 35, 12, 21, 36, 11, 21, 37, 9,  21, 38, 10, 21,
+                  39, 4,  15, 40, 4,  23, 41, 5,  27, 42, 6,  7,  13, 22, 43,
+                  7,  14, 44, 7,  24, 45, 7,  21, 46, 6,  26, 47, 2,  3,  17,
+                  23, 48, 2,  3,  18, 23, 49, 2,  3,  19, 23, 50, 2,  3,  20,
+                  23, 51, 17, 21, 52, 18, 21, 53, 19, 21, 54, 20, 21, 55, 2,
+                  14, 56, 2,  25, 57, 3,  27, 58, 2,  59};
+  scs_int Ap[] = {0,  5,  8,  11, 14, 19,  24,  29,  34,  37,  40,
+                  43, 46, 49, 52, 55, 60,  63,  66,  69,  72,  77,
+                  82, 87, 92, 95, 98, 101, 104, 107, 110, 113, 115};
+
+  scs_float Px[] = {10., 1., 10., 1., 1., 10.};
+  scs_int Pi[] = {0, 0, 1, 0, 1, 2};
+  scs_int Pp[] = {0, 1, 3, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+                  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6};
+
+  scs_float b[] = {
+      0.00000000e+00, 0.00000000e+00, 4.40000000e+01, -2.22044605e-16,
+      0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,
+      1.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,
+      0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,
+      0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,
+      0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,
+      0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,
+      0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,
+      0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,
+      0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,
+      0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,
+      0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,
+      0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,
+      0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,
+      0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00};
+  scs_float c[] = {0., -0.4,  0., 0., 0., 0.,   0.,    0., 0., 0., 0.,
+                   0., -0.32, 0., 0., 0., -0.6, 0.,    0., 0., 0., 0.,
+                   0., 0.,    0., 0., 0., 0.,   -0.48, 0., 0., 10.};
+
+  scs_int m = 60;
+  scs_int n = 32;
+
+  scs_float bl[] = {
+      -1e+20, -1e+20, -1e+20, -1e+20, -1e+20, -1e+20, -1e+20, -1e+20, -1e+20,
+      -1e+20, -1e+20, -1e+20, -1e+20, -1e+20, -1e+20, -1e+20, -1e+20, -1e+20,
+      -1e+20, 0.0,    0.0,    0.0,    0.0,    0.0,    0.0,    0.0,    0.0,
+      0.0,    0.0,    0.0,    0.0,    0.0,    0.0,    0.0,    0.0,    0.0,
+      0.0,    0.0,    0.0,    0.0,    0.0,    0.0,    0.0,    0.0,    0.0,
+      0.0,    0.0,    0.0,    0.0,    0.0,    0.0};
+  scs_float bu[] = {0.0,   0.0,   0.0,   80.0,  500.0, 0.0,   0.0,   80.0,
+                    500.0, 0.0,   0.0,   0.0,   0.0,   0.0,   0.0,   0.0,
+                    0.0,   310.0, 300.0, 1e+20, 1e+20, 1e+20, 1e+20, 1e+20,
+                    1e+20, 1e+20, 1e+20, 1e+20, 1e+20, 1e+20, 1e+20, 1e+20,
+                    1e+20, 1e+20, 1e+20, 1e+20, 1e+20, 1e+20, 1e+20, 1e+20,
+                    1e+20, 1e+20, 1e+20, 1e+20, 1e+20, 1e+20, 1e+20, 1e+20,
+                    1e+20, 1e+20, 1e+20};
+  scs_int bsize = 52;
+  scs_int z = 8;
+
+  scs_float opt = -1.5907818;
+  /* end data */
+
+  d->m = m;
+  d->n = n;
+  d->b = b;
+  d->c = c;
+
+  d->A = (ScsMatrix *)scs_calloc(1, sizeof(ScsMatrix));
+  d->P = (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;
+
+  d->P->m = n;
+  d->P->n = n;
+
+  d->P->x = Px;
+  d->P->i = Pi;
+  d->P->p = Pp;
+
+  k->bsize = bsize;
+  k->bl = bl;
+  k->bu = bu;
+  k->z = z;
+
+  scs_set_default_settings(stgs);
+  stgs->eps_abs = 1e-7;
+  stgs->eps_rel = 1e-7;
+  stgs->eps_infeas = 1e-9;
+
+  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("qafiro_tiny_qp: SCS failed to produce outputflag SCS_SOLVED",
+            success);
+  fail = verify_solution_correct(d, k, stgs, &info, sol, exitflag);
+
+  /* test warm-starting */
+  stgs->warm_start = 1;
+  exitflag = scs(d, k, stgs, sol, &info);
+  /* 25 iters should be enough if warm-started */
+  mu_assert("qafiro_tiny_qp: warm-start failure", info.iter <= 50);
+  success = ABS(perr) < 1e-4 && ABS(derr) < 1e-4 && exitflag == SCS_SOLVED;
+
+  mu_assert("qafiro_tiny_qp: SCS failed to produce outputflag SCS_SOLVED",
+            success);
+
+  /* test other settings */
+  stgs->warm_start = 0;
+  stgs->normalize = 0;
+  stgs->adaptive_scale = 0;
+  stgs->acceleration_lookback = 10;
+  stgs->acceleration_interval = 10;
+  stgs->log_csv_filename = "qafiro_tiny_qp.csv";
+
+  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("qafiro_tiny_qp: SCS failed to produce outputflag SCS_SOLVED",
+            success);
+
+  /* test other settings */
+  stgs->warm_start = 0;
+  stgs->normalize = 0;
+  stgs->adaptive_scale = 0;
+  stgs->acceleration_lookback = -10;
+  stgs->acceleration_interval = 10;
+  stgs->log_csv_filename = "qafiro_tiny_qp.csv";
+
+  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("qafiro_tiny_qp: SCS failed to produce outputflag SCS_SOLVED",
+            success);
+
+  SCS(free_sol)(sol);
+  scs_free(d->A);
+  scs_free(d->P);
+  scs_free(k);
+  scs_free(stgs);
+  scs_free(d);
+  return fail;
+}

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

@@ -0,0 +1,45 @@
+#include "glbopts.h"
+#include "minunit.h"
+#include "problem_utils.h"
+#include "scs.h"
+#include "util.h"
+
+static const char *random_prob(void) {
+  scs_int read_status;
+  ScsData *d;
+  ScsCone *k;
+  ScsSettings *stgs;
+  ScsSolution *sol;
+  ScsInfo info = {0};
+  scs_int exitflag;
+  scs_float perr, derr;
+  scs_int success;
+  const char *fail;
+
+  scs_float OPT = 5.751458006385587;
+
+  read_status = SCS(read_data)("test/problems/random_prob", &d, &k, &stgs);
+
+  if (read_status < 0) {
+    return "Data read failure, exit.\n";
+  }
+
+  stgs->eps_abs = 1e-6;
+  stgs->eps_rel = 1e-6;
+
+  sol = (ScsSolution *)scs_calloc(1, sizeof(ScsSolution));
+  exitflag = scs(d, k, stgs, sol, &info);
+
+  perr = SCS(dot)(d->c, sol->x, d->n) - OPT;
+  derr = -SCS(dot)(d->b, sol->y, d->m) - 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("random_prob: SCS failed to produce SCS_SOLVED", success);
+  fail = verify_solution_correct(d, k, stgs, &info, sol, exitflag);
+  SCS(free_data)(d, k, stgs);
+  SCS(free_sol)(sol);
+  return fail;
+}