scs 0.2.3 → 0.3.0

data/vendor/scs/test/rng.h

@@ -0,0 +1,109 @@
+/*    This program by D E Knuth is in the public domain and freely copyable
+ *    AS LONG AS YOU MAKE ABSOLUTELY NO CHANGES!
+ *    It is explained in Seminumerical Algorithms, 3rd edition, Section 3.6
+ *    (or in the errata to the 2nd edition --- see
+ *        http://www-cs-faculty.stanford.edu/~knuth/taocp.html
+ *    in the changes to Volume 2 on pages 171 and following).              */
+
+/*    N.B. The MODIFICATIONS introduced in the 9th printing (2002) are
+      included here; there's no backwards compatibility with the original. */
+
+/*    This version also adopts Brendan McKay's suggestion to
+      accommodate naive users who forget to call ran_start(seed).          */
+
+/*    If you find any bugs, please report them immediately to
+ *                 taocp@cs.stanford.edu
+ *    (and you will be rewarded if the bug is genuine). Thanks!            */
+
+/************ see the book for explanations and caveats! *******************/
+/************ in particular, you need two's complement arithmetic **********/
+
+#define KK 100                                  /* the long lag */
+#define LL 37                                   /* the short lag */
+#define MM (1L << 30)                           /* the modulus */
+#define mod_diff(x, y) (((x) - (y)) & (MM - 1)) /* subtraction mod MM */
+
+long ran_x[KK]; /* the generator state */
+
+#ifdef __STDC__
+void ran_array(long aa[], int n)
+#else
+void ran_array(aa, n) /* put n new random numbers in aa */
+    long *aa;         /* destination */
+int n;                /* array length (must be at least KK) */
+#endif
+{
+  register int i, j;
+  for (j = 0; j < KK; j++)
+    aa[j] = ran_x[j];
+  for (; j < n; j++)
+    aa[j] = mod_diff(aa[j - KK], aa[j - LL]);
+  for (i = 0; i < LL; i++, j++)
+    ran_x[i] = mod_diff(aa[j - KK], aa[j - LL]);
+  for (; i < KK; i++, j++)
+    ran_x[i] = mod_diff(aa[j - KK], ran_x[i - LL]);
+}
+
+/* the following routines are from exercise 3.6--15 */
+/* after calling ran_start, get new randoms by, e.g., "x=ran_arr_next()" */
+
+#define QUALITY 1009 /* recommended quality level for high-res use */
+long ran_arr_buf[QUALITY];
+long ran_arr_dummy = -1, ran_arr_started = -1;
+long *ran_arr_ptr = &ran_arr_dummy; /* the next random number, or -1 */
+
+#define TT 70             /* guaranteed separation between streams */
+#define is_odd(x) ((x)&1) /* units bit of x */
+
+#ifdef __STDC__
+void ran_start(long seed)
+#else
+void ran_start(seed)  /* do this before using ran_array */
+    long seed;        /* selector for different streams */
+#endif
+{
+  register int t, j;
+  long x[KK + KK - 1]; /* the preparation buffer */
+  register long ss = (seed + 2) & (MM - 2);
+  for (j = 0; j < KK; j++) {
+    x[j] = ss; /* bootstrap the buffer */
+    ss <<= 1;
+    if (ss >= MM)
+      ss -= MM - 2; /* cyclic shift 29 bits */
+  }
+  x[1]++; /* make x[1] (and only x[1]) odd */
+  for (ss = seed & (MM - 1), t = TT - 1; t;) {
+    for (j = KK - 1; j > 0; j--)
+      x[j + j] = x[j], x[j + j - 1] = 0; /* "square" */
+    for (j = KK + KK - 2; j >= KK; j--)
+      x[j - (KK - LL)] = mod_diff(x[j - (KK - LL)], x[j]),
+                  x[j - KK] = mod_diff(x[j - KK], x[j]);
+    if (is_odd(ss)) { /* "multiply by z" */
+      for (j = KK; j > 0; j--)
+        x[j] = x[j - 1];
+      x[0] = x[KK]; /* shift the buffer cyclically */
+      x[LL] = mod_diff(x[LL], x[KK]);
+    }
+    if (ss)
+      ss >>= 1;
+    else
+      t--;
+  }
+  for (j = 0; j < LL; j++)
+    ran_x[j + KK - LL] = x[j];
+  for (; j < KK; j++)
+    ran_x[j - LL] = x[j];
+  for (j = 0; j < 10; j++)
+    ran_array(x, KK + KK - 1); /* warm things up */
+  ran_arr_ptr = &ran_arr_started;
+}
+
+#define ran_arr_next() (*ran_arr_ptr >= 0 ? *ran_arr_ptr++ : ran_arr_cycle())
+long ran_arr_cycle(void) {
+  if (ran_arr_ptr == &ran_arr_dummy)
+    ran_start(314159L); /* the user forgot to initialize */
+  ran_array(ran_arr_buf, QUALITY);
+  ran_arr_buf[KK] = -1;
+  ran_arr_ptr = ran_arr_buf + 1;
+  return ran_arr_buf[0];
+}

data/vendor/scs/test/run_from_file.c

@@ -12,16 +12,24 @@ scs_int override_setting(ScsSettings *s, char *param, char *val) {
     s->rho_x = atof(val);
   } else if (strcmp(param, "max_iters") == 0) {
     s->max_iters = atoi(val);
-  } else if (strcmp(param, "eps") == 0) {
-    s->eps = atof(val);
+  } else if (strcmp(param, "eps_abs") == 0) {
+    s->eps_abs = atof(val);
+  } else if (strcmp(param, "eps_rel") == 0) {
+    s->eps_rel = atof(val);
+  } else if (strcmp(param, "eps_infeas") == 0) {
+    s->eps_infeas = atof(val);
   } else if (strcmp(param, "alpha") == 0) {
     s->alpha = atof(val);
-  } else if (strcmp(param, "cg_rate") == 0) {
-    s->cg_rate = atof(val);
   } else if (strcmp(param, "verbose") == 0) {
     s->verbose = atoi(val);
   } else if (strcmp(param, "acceleration_lookback") == 0) {
     s->acceleration_lookback = atoi(val);
+  } else if (strcmp(param, "acceleration_interval") == 0) {
+    s->acceleration_interval = atoi(val);
+  } else if (strcmp(param, "adaptive_scale") == 0) {
+    s->adaptive_scale = atoi(val);
+  } else if (strcmp(param, "log_csv_filename") == 0) {
+    s->log_csv_filename = val;
   } else {
     return -1;
   }
@@ -36,6 +44,7 @@ int main(int argc, char **argv) {
   scs_int read_status;
   ScsData *d;
   ScsCone *k;
+  ScsSettings *stgs;
   ScsSolution *sol;
   ScsInfo info = {0};
   scs_int i;
@@ -44,7 +53,7 @@ int main(int argc, char **argv) {
     return -1;
   }
   filename = argv[1];
-  read_status = SCS(read_data)(filename, &d, &k);
+  read_status = SCS(read_data)(filename, &d, &k, &stgs);
   if (read_status < 0) {
     scs_printf("Data read failure, exit.\n");
     return -1;
@@ -52,18 +61,18 @@ int main(int argc, char **argv) {
   for (i = 2; i < argc; i += 2) {
     if (argc < i + 2) {
       scs_printf("Incorrect number of arguments supplied\n.");
-      SCS(free_data)(d, k);
+      SCS(free_data)(d, k, stgs);
       return -1;
     }
-    if (override_setting(d->stgs, argv[i], argv[i + 1]) < 0) {
+    if (override_setting(stgs, argv[i], argv[i + 1]) < 0) {
       scs_printf("Unrecognized setting %s\n", argv[i]);
-      SCS(free_data)(d, k);
+      SCS(free_data)(d, k, stgs);
       return -1;
     }
   }
   sol = scs_calloc(1, sizeof(ScsSolution));
-  scs(d, k, sol, &info);
-  SCS(free_data)(d, k);
+  scs(d, k, stgs, sol, &info);
+  SCS(free_data)(d, k, stgs);
   SCS(free_sol)(sol);
   return 0;
 }

data/vendor/scs/test/run_tests.c

@@ -6,16 +6,40 @@
 #include "scs.h"
 
 /* Include Tests */
-#include "problems/small_lp.h"
+#include "problems/degenerate.h"
+#include "problems/hs21_tiny_qp.h"
+#include "problems/hs21_tiny_qp_rw.h"
+#include "problems/infeasible_tiny_qp.h"
+#include "problems/qafiro_tiny_qp.h"
+#include "problems/random_prob.h"
 #include "problems/rob_gauss_cov_est.h"
-#include "problems/small_random_socp.h"
+#include "problems/small_lp.h"
+#include "problems/test_fails.h"
+#include "problems/unbounded_tiny_qp.h"
 
 int tests_run = 0;
 
 static const char *all_tests(void) {
+  scs_printf("test_fails\n");
+  mu_run_test(test_fails);
+  scs_printf("degenerate\n");
+  mu_run_test(degenerate);
+  scs_printf("small_lp\n");
   mu_run_test(small_lp);
+  scs_printf("rob_gauss_cov_est\n");
   mu_run_test(rob_gauss_cov_est);
-  mu_run_test(small_random_socp);
+  scs_printf("hs21_tiny_qp\n");
+  mu_run_test(hs21_tiny_qp);
+  scs_printf("hs21_tiny_qp_rw\n");
+  mu_run_test(hs21_tiny_qp_rw);
+  scs_printf("qafiro_tiny_qp\n");
+  mu_run_test(qafiro_tiny_qp);
+  scs_printf("infeasible_tiny_qp\n");
+  mu_run_test(infeasible_tiny_qp);
+  scs_printf("unbounded_tiny_qp\n");
+  mu_run_test(unbounded_tiny_qp);
+  scs_printf("random_prob\n");
+  mu_run_test(random_prob);
   return 0;
 }
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scs
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.0
 platform: ruby
 authors:
 - Andrew Kane
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-09-09 00:00:00.000000000 Z
+date: 2021-10-05 00:00:00.000000000 Z
 dependencies: []
 description:
 email: andrew@ankane.org
@@ -25,6 +25,7 @@ files:
 - lib/scs/ffi.rb
 - lib/scs/solver.rb
 - lib/scs/version.rb
+- vendor/scs/CITATION.cff
 - vendor/scs/CMakeLists.txt
 - vendor/scs/LICENSE.txt
 - vendor/scs/Makefile
@@ -40,15 +41,15 @@ files:
 - vendor/scs/include/scs.h
 - vendor/scs/include/scs_blas.h
 - vendor/scs/include/util.h
-- vendor/scs/linsys/amatrix.c
-- vendor/scs/linsys/amatrix.h
-- vendor/scs/linsys/amatrix.o
 - vendor/scs/linsys/cpu/direct/private.c
 - vendor/scs/linsys/cpu/direct/private.h
 - vendor/scs/linsys/cpu/direct/private.o
 - vendor/scs/linsys/cpu/indirect/private.c
 - vendor/scs/linsys/cpu/indirect/private.h
 - vendor/scs/linsys/cpu/indirect/private.o
+- vendor/scs/linsys/csparse.c
+- vendor/scs/linsys/csparse.h
+- vendor/scs/linsys/csparse.o
 - vendor/scs/linsys/external/amd/LICENSE.txt
 - vendor/scs/linsys/external/amd/SuiteSparse_config.c
 - vendor/scs/linsys/external/amd/SuiteSparse_config.h
@@ -93,6 +94,9 @@ files:
 - vendor/scs/linsys/gpu/gpu.h
 - vendor/scs/linsys/gpu/indirect/private.c
 - vendor/scs/linsys/gpu/indirect/private.h
+- vendor/scs/linsys/scs_matrix.c
+- vendor/scs/linsys/scs_matrix.h
+- vendor/scs/linsys/scs_matrix.o
 - vendor/scs/scs.mk
 - vendor/scs/src/aa.c
 - vendor/scs/src/aa.o
@@ -108,19 +112,27 @@ files:
 - vendor/scs/src/rw.o
 - vendor/scs/src/scs.c
 - vendor/scs/src/scs.o
+- vendor/scs/src/scs_indir.o
 - vendor/scs/src/scs_version.c
 - vendor/scs/src/scs_version.o
 - vendor/scs/src/util.c
 - vendor/scs/src/util.o
-- vendor/scs/test/data/small_random_socp
 - vendor/scs/test/minunit.h
 - vendor/scs/test/problem_utils.h
+- vendor/scs/test/problems/degenerate.h
+- vendor/scs/test/problems/hs21_tiny_qp.h
+- vendor/scs/test/problems/hs21_tiny_qp_rw.h
+- vendor/scs/test/problems/infeasible_tiny_qp.h
+- vendor/scs/test/problems/qafiro_tiny_qp.h
+- vendor/scs/test/problems/random_prob
+- vendor/scs/test/problems/random_prob.h
 - vendor/scs/test/problems/rob_gauss_cov_est.h
 - vendor/scs/test/problems/small_lp.h
-- vendor/scs/test/problems/small_random_socp.h
+- vendor/scs/test/problems/test_fails.h
+- vendor/scs/test/problems/unbounded_tiny_qp.h
 - vendor/scs/test/random_socp_prob.c
+- vendor/scs/test/rng.h
 - vendor/scs/test/run_from_file.c
-- vendor/scs/test/run_tests
 - vendor/scs/test/run_tests.c
 homepage: https://github.com/ankane/scs
 licenses:

data/vendor/scs/linsys/amatrix.c

@@ -1,305 +0,0 @@
-/* contains routines common to direct and indirect sparse solvers */
-#include "amatrix.h"
-
-#include "linsys.h"
-
-#define MIN_SCALE (1e-4)
-#define MAX_SCALE (1e4)
-#define NUM_SCALE_PASSES 10 /* additional passes don't help much */
-
-scs_int SCS(copy_a_matrix)(ScsMatrix **dstp, const ScsMatrix *src) {
-  scs_int Anz = src->p[src->n];
-  ScsMatrix *A = (ScsMatrix *)scs_calloc(1, sizeof(ScsMatrix));
-  if (!A) {
-    return 0;
-  }
-  A->n = src->n;
-  A->m = src->m;
-  A->x = (scs_float *)scs_malloc(sizeof(scs_float) *
-                                 Anz); /* A values, size: NNZ A */
-  A->i = (scs_int *)scs_malloc(sizeof(scs_int) *
-                               Anz); /* A row index, size: NNZ A */
-  A->p = (scs_int *)scs_malloc(sizeof(scs_int) *
-                               (src->n + 1)); /* A column pointer, size: n+1 */
-  if (!A->x || !A->i || !A->p) {
-    return 0;
-  }
-  memcpy(A->x, src->x, sizeof(scs_float) * Anz);
-  memcpy(A->i, src->i, sizeof(scs_int) * Anz);
-  memcpy(A->p, src->p, sizeof(scs_int) * (src->n + 1));
-  *dstp = A;
-  return 1;
-}
-
-scs_int SCS(validate_lin_sys)(const ScsMatrix *A) {
-  scs_int i, r_max, Anz;
-  if (!A->x || !A->i || !A->p) {
-    scs_printf("data incompletely specified\n");
-    return -1;
-  }
-  /* detects some errors in A col ptrs: */
-  Anz = A->p[A->n];
-  if (Anz > 0) {
-    for (i = 0; i < A->n; ++i) {
-      if (A->p[i] == A->p[i + 1]) {
-        scs_printf(
-            "WARN: A->p (column pointers) not strictly increasing, "
-            "column %li empty\n",
-            (long)i);
-      } else if (A->p[i] > A->p[i + 1]) {
-        scs_printf("ERROR: A->p (column pointers) decreasing\n");
-        return -1;
-      }
-    }
-  }
-  if (((scs_float)Anz / A->m > A->n) || (Anz < 0)) {
-    scs_printf("Anz (nonzeros in A) = %li, outside of valid range\n",
-               (long)Anz);
-    return -1;
-  }
-  r_max = 0;
-  for (i = 0; i < Anz; ++i) {
-    if (A->i[i] > r_max) {
-      r_max = A->i[i];
-    }
-  }
-  if (r_max > A->m - 1) {
-    scs_printf("number of rows in A inconsistent with input dimension\n");
-    return -1;
-  }
-  return 0;
-}
-
-void SCS(free_a_matrix)(ScsMatrix *A) {
-  if (A) {
-    scs_free(A->x);
-    scs_free(A->i);
-    scs_free(A->p);
-    scs_free(A);
-  }
-}
-
-#if EXTRA_VERBOSE > 0
-static void print_a_matrix(const ScsMatrix *A) {
-  scs_int i, j;
-  /* TODO: this is to prevent clogging stdout */
-  if (A->p[A->n] < 2500) {
-    scs_printf("\n");
-    for (i = 0; i < A->n; ++i) {
-      scs_printf("Col %li: ", (long)i);
-      for (j = A->p[i]; j < A->p[i + 1]; j++) {
-        scs_printf("A[%li,%li] = %4f, ", (long)A->i[j], (long)i, A->x[j]);
-      }
-      scs_printf("norm col = %4f\n",
-                 SCS(norm)(&(A->x[A->p[i]]), A->p[i + 1] - A->p[i]));
-    }
-    scs_printf("norm A = %4f\n", SCS(norm)(A->x, A->p[A->n]));
-  }
-}
-#endif
-
-void SCS(_normalize_a)(ScsMatrix *A, const ScsSettings *stgs, const ScsCone *k,
-                       ScsScaling *scal) {
-  scs_float *D = (scs_float *)scs_malloc(A->m * sizeof(scs_float));
-  scs_float *E = (scs_float *)scs_malloc(A->n * sizeof(scs_float));
-  scs_float *Dt = (scs_float *)scs_malloc(A->m * sizeof(scs_float));
-  scs_float *Et = (scs_float *)scs_malloc(A->n * sizeof(scs_float));
-  scs_float *nms = (scs_float *)scs_calloc(A->m, sizeof(scs_float));
-  scs_int i, j, l, count, delta, *boundaries;
-  scs_int num_boundaries = SCS(get_cone_boundaries)(k, &boundaries);
-  scs_float wrk;
-
-#if EXTRA_VERBOSE > 0
-  SCS(timer) normalize_timer;
-  SCS(tic)(&normalize_timer);
-  scs_printf("normalizing A\n");
-  print_a_matrix(A);
-#endif
-
-  for (l = 0; l < NUM_SCALE_PASSES; ++l) {
-    memset(D, 0, A->m * sizeof(scs_float));
-    memset(E, 0, A->n * sizeof(scs_float));
-    /* calculate row norms */
-    for (i = 0; i < A->n; ++i) {
-      for (j = A->p[i]; j < A->p[i + 1]; ++j) {
-        D[A->i[j]] = MAX(D[A->i[j]], ABS(A->x[j]));
-      }
-    }
-    for (i = 0; i < A->m; ++i) {
-      D[i] = SQRTF(D[i]);
-      D[i] = D[i] < MIN_SCALE ? 1.0 : D[i];
-      D[i] = D[i] > MAX_SCALE ? MAX_SCALE : D[i];
-    }
-    /* calculate col norms, E */
-    for (i = 0; i < A->n; ++i) {
-      E[i] = SCS(norm_inf)(&(A->x[A->p[i]]), A->p[i + 1] - A->p[i]);
-      E[i] = SQRTF(E[i]);
-      E[i] = E[i] < MIN_SCALE ? 1.0 : E[i];
-      E[i] = E[i] > MAX_SCALE ? MAX_SCALE : E[i];
-    }
-
-    /* mean of D across each cone  */
-    count = boundaries[0];
-    for (i = 1; i < num_boundaries; ++i) {
-      wrk = 0;
-      delta = boundaries[i];
-      for (j = count; j < count + delta; ++j) {
-        wrk += D[j];
-      }
-      wrk /= delta;
-      for (j = count; j < count + delta; ++j) {
-        D[j] = wrk;
-      }
-      count += delta;
-    }
-
-    /* scale the rows with D */
-    for (i = 0; i < A->n; ++i) {
-      for (j = A->p[i]; j < A->p[i + 1]; ++j) {
-        A->x[j] /= D[A->i[j]];
-      }
-    }
-
-    /* scale the cols with E */
-    for (i = 0; i < A->n; ++i) {
-      SCS(scale_array)(&(A->x[A->p[i]]), 1.0 / E[i], A->p[i + 1] - A->p[i]);
-    }
-
-    /* Accumulate scaling */
-    for (i = 0; i < A->m; ++i) {
-      Dt[i] = (l == 0) ? D[i] : Dt[i] * D[i];
-    }
-    for (i = 0; i < A->n; ++i) {
-      Et[i] = (l == 0) ? E[i] : Et[i] * E[i];
-    }
-  }
-  scs_free(boundaries);
-  scs_free(D);
-  scs_free(E);
-
-  /* calculate mean of row norms of A */
-  for (i = 0; i < A->n; ++i) {
-    for (j = A->p[i]; j < A->p[i + 1]; ++j) {
-      wrk = A->x[j];
-      nms[A->i[j]] += wrk * wrk;
-    }
-  }
-  scal->mean_norm_row_a = 0.0;
-  for (i = 0; i < A->m; ++i) {
-    scal->mean_norm_row_a += SQRTF(nms[i]) / A->m;
-  }
-  scs_free(nms);
-
-  /* calculate mean of col norms of A */
-  scal->mean_norm_col_a = 0.0;
-  for (i = 0; i < A->n; ++i) {
-    scal->mean_norm_col_a +=
-        SCS(norm)(&(A->x[A->p[i]]), A->p[i + 1] - A->p[i]) / A->n;
-  }
-
-  /* scale up by d->SCALE if not equal to 1 */
-  if (stgs->scale != 1) {
-    SCS(scale_array)(A->x, stgs->scale, A->p[A->n]);
-  }
-
-  scal->D = Dt;
-  scal->E = Et;
-
-#if EXTRA_VERBOSE > 0
-  scs_printf("finished normalizing A, time: %1.2es\n",
-             SCS(tocq)(&normalize_timer) / 1e3);
-  print_a_matrix(A);
-#endif
-}
-
-void SCS(_un_normalize_a)(ScsMatrix *A, const ScsSettings *stgs,
-                          const ScsScaling *scal) {
-  scs_int i, j;
-  scs_float *D = scal->D;
-  scs_float *E = scal->E;
-  for (i = 0; i < A->n; ++i) {
-    SCS(scale_array)
-    (&(A->x[A->p[i]]), E[i] / stgs->scale, A->p[i + 1] - A->p[i]);
-  }
-  for (i = 0; i < A->n; ++i) {
-    for (j = A->p[i]; j < A->p[i + 1]; ++j) {
-      A->x[j] *= D[A->i[j]];
-    }
-  }
-}
-
-void SCS(_accum_by_atrans)(scs_int n, scs_float *Ax, scs_int *Ai, scs_int *Ap,
-                           const scs_float *x, scs_float *y) {
-  /* y += A'*x
-     A in column compressed format
-     parallelizes over columns (rows of A')
-   */
-  scs_int p, j;
-  scs_int c1, c2;
-  scs_float yj;
-#if EXTRA_VERBOSE > 0
-  SCS(timer) mult_by_atrans_timer;
-  SCS(tic)(&mult_by_atrans_timer);
-#endif
-#ifdef _OPENMP
-#pragma omp parallel for private(p, c1, c2, yj)
-#endif
-  for (j = 0; j < n; j++) {
-    yj = y[j];
-    c1 = Ap[j];
-    c2 = Ap[j + 1];
-    for (p = c1; p < c2; p++) {
-      yj += Ax[p] * x[Ai[p]];
-    }
-    y[j] = yj;
-  }
-#if EXTRA_VERBOSE > 0
-  scs_printf("mult By A trans time: %1.2es\n",
-             SCS(tocq)(&mult_by_atrans_timer) / 1e3);
-#endif
-}
-
-scs_float SCS(cumsum)(scs_int *p, scs_int *c, scs_int n) {
-  scs_int i, nz = 0;
-  scs_float nz2 = 0;
-  if (!p || !c) {
-    return (-1);
-  } /* check inputs */
-  for (i = 0; i < n; i++) {
-    p[i] = nz;
-    nz += c[i];
-    nz2 += c[i]; /* also in scs_float to avoid scs_int overflow */
-    c[i] = p[i]; /* also copy p[0..n-1] back into c[0..n-1]*/
-  }
-  p[n] = nz;
-  return nz2; /* return sum (c [0..n-1]) */
-}
-
-void SCS(_accum_by_a)(scs_int n, scs_float *Ax, scs_int *Ai, scs_int *Ap,
-                      const scs_float *x, scs_float *y) {
-  /*y += A*x
-    A in column compressed format
-    this parallelizes over columns and uses
-    pragma atomic to prevent concurrent writes to y
-   */
-  scs_int p, j;
-  scs_int c1, c2;
-  scs_float xj;
-#if EXTRA_VERBOSE > 0
-  SCS(timer) mult_by_a_timer;
-  SCS(tic)(&mult_by_a_timer);
-#endif
-  /*#pragma omp parallel for private(p,c1,c2,xj)  */
-  for (j = 0; j < n; j++) {
-    xj = x[j];
-    c1 = Ap[j];
-    c2 = Ap[j + 1];
-    for (p = c1; p < c2; p++) {
-      /*#pragma omp atomic */
-      y[Ai[p]] += Ax[p] * xj;
-    }
-  }
-#if EXTRA_VERBOSE > 0
-  scs_printf("mult By A time: %1.2es\n", SCS(tocq)(&mult_by_a_timer) / 1e3);
-#endif
-}

data/vendor/scs/linsys/amatrix.h

@@ -1,36 +0,0 @@
-#ifndef AMATRIX_H_GUARD
-#define AMATRIX_H_GUARD
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "glbopts.h"
-#include "linalg.h"
-#include "linsys.h"
-#include "scs.h"
-#include "util.h"
-
-/* this struct defines the data matrix A */
-struct SCS_A_DATA_MATRIX {
-  /* A is supplied in column compressed format */
-  scs_float *x; /* A values, size: NNZ A */
-  scs_int *i;   /* A row index, size: NNZ A */
-  scs_int *p;   /* A column pointer, size: n+1 */
-  scs_int m, n; /* m rows, n cols */
-};
-
-void SCS(_accum_by_atrans)(scs_int n, scs_float *Ax, scs_int *Ai, scs_int *Ap,
-                           const scs_float *x, scs_float *y);
-void SCS(_accum_by_a)(scs_int n, scs_float *Ax, scs_int *Ai, scs_int *Ap,
-                      const scs_float *x, scs_float *y);
-void SCS(_normalize_a)(ScsMatrix *A, const ScsSettings *stgs, const ScsCone *k,
-                       ScsScaling *scal);
-void SCS(_un_normalize_a)(ScsMatrix *A, const ScsSettings *stgs,
-                          const ScsScaling *scal);
-scs_float SCS(cumsum)(scs_int *p, scs_int *c, scs_int n);
-
-#ifdef __cplusplus
-}
-#endif
-#endif

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

@@ -1,33 +0,0 @@
-#include "rw.h"
-#include "scs.h"
-#include "util.h"
-
-#define OPT (1.530897)
-
-static const char *small_random_socp(void) {
-  ScsData *d;
-  ScsCone *k;
-  ScsSolution *sol;
-  ScsInfo info = {0};
-  scs_int exitflag, success;
-  scs_float perr, derr;
-  const char *filename = "test/data/small_random_socp";
-
-  SCS(read_data)(filename, &d, &k);
-  sol = scs_calloc(1, sizeof(ScsSolution));
-  exitflag = scs(d, k, 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;
-
-  SCS(free_data)(d, k);
-  SCS(free_sol)(sol);
-  mu_assert("small_random_socp: SCS failed to produce outputflag SCS_SOLVED",
-            success);
-  return 0;
-}

data/vendor/scs/test/run_tests

@@ -1,2 +0,0 @@
-out/run_tests_indirect
-out/run_tests_direct