scs 0.2.2 → 0.3.2

data/vendor/scs/linsys/cpu/indirect/private.c

@@ -1,43 +1,57 @@
 #include "private.h"
+#include "linsys.h"
+#include "util.h"
+#include <limits.h>
 
-#define CG_BEST_TOL 1e-9
-#define CG_MIN_TOL 1e-1
-
-char *SCS(get_lin_sys_method)(const ScsMatrix *A, const ScsSettings *stgs) {
-  char *str = (char *)scs_malloc(sizeof(char) * 128);
-  sprintf(str, "sparse-indirect, nnz in A = %li, CG tol ~ 1/iter^(%2.2f)",
-          (long)A->p[A->n], stgs->cg_rate);
-  return str;
+const char *SCS(get_lin_sys_method)() {
+  return "sparse-indirect";
 }
 
+/*
 char *SCS(get_lin_sys_summary)(ScsLinSysWork *p, const ScsInfo *info) {
   char *str = (char *)scs_malloc(sizeof(char) * 128);
-  sprintf(str,
-          "\tLin-sys: avg # CG iterations: %2.2f, avg solve time: %1.2es\n",
-          (scs_float)p->tot_cg_its / (info->iter + 1),
-          p->total_solve_time / (info->iter + 1) / 1e3);
+  sprintf(str, "lin-sys: avg cg its: %2.2f\n",
+          (scs_float)p->tot_cg_its / (info->iter + 1));
   p->tot_cg_its = 0;
-  p->total_solve_time = 0;
   return str;
 }
+*/
 
-/* M = inv ( diag ( RHO_X * I + A'A ) ) */
-static void get_preconditioner(const ScsMatrix *A, const ScsSettings *stgs,
-                               ScsLinSysWork *p) {
-  scs_int i;
+/* Not possible to do this on the fly due to M_ii += a_i' (R_y)^-1 a_i */
+/* set M = inv ( diag ( R_x + P + A' R_y^{-1} A ) ) */
+static void set_preconditioner(ScsLinSysWork *p) {
+  scs_int i, k;
   scs_float *M = p->M;
+  const ScsMatrix *A = p->A;
+  const ScsMatrix *P = p->P;
 
-#if EXTRA_VERBOSE > 0
+#if VERBOSITY > 0
   scs_printf("getting pre-conditioner\n");
 #endif
 
-  for (i = 0; i < A->n; ++i) {
-    M[i] = 1 / (stgs->rho_x +
-                SCS(norm_sq)(&(A->x[A->p[i]]), A->p[i + 1] - A->p[i]));
-    /* M[i] = 1; */
+  /* M_ii = (R_x)_i + P_ii + a_i' (R_y)^-1 a_i */
+  for (i = 0; i < A->n; ++i) { /* cols */
+    /* M_ii = (R_x)_i */
+    M[i] = p->diag_r[i];
+    /* M_ii += a_i' (R_y)^-1 a_i */
+    for (k = A->p[i]; k < A->p[i + 1]; ++k) {
+      /* A->i[k] is row of entry k with value A->x[k] */
+      M[i] += A->x[k] * A->x[k] / p->diag_r[A->n + A->i[k]];
+    }
+    if (P) {
+      for (k = P->p[i]; k < P->p[i + 1]; k++) {
+        /* diagonal element only */
+        if (P->i[k] == i) { /* row == col */
+          /* M_ii += P_ii */
+          M[i] += P->x[k];
+          break;
+        }
+      }
+    }
+    /* finally invert for pre-conditioner */
+    M[i] = 1. / M[i];
   }
-
-#if EXTRA_VERBOSE > 0
+#if VERBOSITY > 0
   scs_printf("finished getting pre-conditioner\n");
 #endif
 }
@@ -54,15 +68,16 @@ static void transpose(const ScsMatrix *A, ScsLinSysWork *p) {
   scs_float *Ax = A->x;
 
   scs_int i, j, q, *z, c1, c2;
-#if EXTRA_VERBOSE > 0
+#if VERBOSITY > 0
   SCS(timer) transpose_timer;
   scs_printf("transposing A\n");
   SCS(tic)(&transpose_timer);
 #endif
 
   z = (scs_int *)scs_calloc(m, sizeof(scs_int));
-  for (i = 0; i < Ap[n]; i++) z[Ai[i]]++; /* row counts */
-  SCS(cumsum)(Cp, z, m);                  /* row pointers */
+  for (i = 0; i < Ap[n]; i++)
+    z[Ai[i]]++;          /* row counts */
+  SCS(cumsum)(Cp, z, m); /* row pointers */
 
   for (j = 0; j < n; j++) {
     c1 = Ap[j];
@@ -76,7 +91,7 @@ static void transpose(const ScsMatrix *A, ScsLinSysWork *p) {
   }
   scs_free(z);
 
-#if EXTRA_VERBOSE > 0
+#if VERBOSITY > 0
   scs_printf("finished transposing A, time: %1.2es\n",
              SCS(tocq)(&transpose_timer) / 1e3);
 #endif
@@ -100,60 +115,86 @@ void SCS(free_lin_sys_work)(ScsLinSysWork *p) {
   }
 }
 
-/*y = (RHO_X * I + A'A)x */
-static void mat_vec(const ScsMatrix *A, const ScsSettings *s, ScsLinSysWork *p,
-                    const scs_float *x, scs_float *y) {
-  scs_float *tmp = p->tmp;
-  memset(tmp, 0, A->m * sizeof(scs_float));
-  SCS(accum_by_a)(A, p, x, tmp);
-  memset(y, 0, A->n * sizeof(scs_float));
-  SCS(accum_by_atrans)(A, p, tmp, y);
-  SCS(add_scaled_array)(y, x, A->n, s->rho_x);
+/* vec -> R_y^{-1} vec */
+static void scale_by_r_y_inv(scs_float *vec, ScsLinSysWork *p) {
+  scs_int i;
+  for (i = 0; i < p->m; ++i) {
+    vec[i] /= p->diag_r[p->n + i];
+  }
+}
+
+/* y += R_x * x  */
+static void accum_by_r_x(scs_float *y, const scs_float *x, ScsLinSysWork *p) {
+  scs_int i;
+  for (i = 0; i < p->n; ++i) {
+    y[i] += p->diag_r[i] * x[i];
+  }
 }
 
-void SCS(accum_by_atrans)(const ScsMatrix *A, ScsLinSysWork *p,
-                          const scs_float *x, scs_float *y) {
-  SCS(_accum_by_atrans)(A->n, A->x, A->i, A->p, x, y);
+/* we use a different accum_by_a here for speed */
+static void accum_by_a(ScsLinSysWork *p, const scs_float *x, scs_float *y) {
+  SCS(accum_by_atrans)(p->At, x, y);
 }
 
-void SCS(accum_by_a)(const ScsMatrix *A, ScsLinSysWork *p, const scs_float *x,
-                     scs_float *y) {
-  SCS(_accum_by_atrans)(p->At->n, p->At->x, p->At->i, p->At->p, x, y);
+/* y = (R_x + P + A' R_y^{-1} A) x */
+static void mat_vec(const ScsMatrix *A, const ScsMatrix *P, ScsLinSysWork *p,
+                    const scs_float *x, scs_float *y) {
+  scs_float *z = p->tmp;
+  memset(z, 0, A->m * sizeof(scs_float)); /* z = 0 */
+  memset(y, 0, A->n * sizeof(scs_float)); /* y = 0 */
+  if (P) {
+    SCS(accum_by_p)(P, x, y); /* y = Px */
+  }
+  accum_by_a(p, x, z);           /* z = Ax */
+  scale_by_r_y_inv(z, p);        /* z = R_y^{-1} A x */
+  SCS(accum_by_atrans)(A, z, y); /* y += A'z, y = Px + A' R_y^{-1} Ax */
+  /* y = R_x * x + Px + A' R_y^{-1} A * x */
+  accum_by_r_x(y, x, p);
 }
 
-static void apply_pre_conditioner(scs_float *M, scs_float *z, scs_float *r,
-                                  scs_int n, scs_float *ipzr) {
+static void apply_pre_conditioner(scs_float *z, scs_float *r, scs_int n,
+                                  ScsLinSysWork *pr) {
   scs_int i;
-  *ipzr = 0;
+  scs_float *M = pr->M;
   for (i = 0; i < n; ++i) {
     z[i] = r[i] * M[i];
-    *ipzr += z[i] * r[i];
   }
 }
 
-ScsLinSysWork *SCS(init_lin_sys_work)(const ScsMatrix *A,
-                                      const ScsSettings *stgs) {
+/* no need to update anything in this case */
+void SCS(update_lin_sys_diag_r)(ScsLinSysWork *p, const scs_float *diag_r) {
+  p->diag_r = diag_r; /* this isn't needed but do it to be safe */
+  set_preconditioner(p);
+}
+
+ScsLinSysWork *SCS(init_lin_sys_work)(const ScsMatrix *A, const ScsMatrix *P,
+                                      const scs_float *diag_r) {
   ScsLinSysWork *p = (ScsLinSysWork *)scs_calloc(1, sizeof(ScsLinSysWork));
-  p->p = (scs_float *)scs_malloc((A->n) * sizeof(scs_float));
-  p->r = (scs_float *)scs_malloc((A->n) * sizeof(scs_float));
-  p->Gp = (scs_float *)scs_malloc((A->n) * sizeof(scs_float));
-  p->tmp = (scs_float *)scs_malloc((A->m) * sizeof(scs_float));
+  p->A = A;
+  p->P = P;
+  p->m = A->m;
+  p->n = A->n;
+
+  p->p = (scs_float *)scs_calloc((A->n), sizeof(scs_float));
+  p->r = (scs_float *)scs_calloc((A->n), sizeof(scs_float));
+  p->Gp = (scs_float *)scs_calloc((A->n), sizeof(scs_float));
+  p->tmp = (scs_float *)scs_calloc((A->m), sizeof(scs_float));
 
   /* memory for A transpose */
-  p->At = (ScsMatrix *)scs_malloc(sizeof(ScsMatrix));
+  p->At = (ScsMatrix *)scs_calloc(1, sizeof(ScsMatrix));
   p->At->m = A->n;
   p->At->n = A->m;
-  p->At->i = (scs_int *)scs_malloc((A->p[A->n]) * sizeof(scs_int));
-  p->At->p = (scs_int *)scs_malloc((A->m + 1) * sizeof(scs_int));
-  p->At->x = (scs_float *)scs_malloc((A->p[A->n]) * sizeof(scs_float));
+  p->At->i = (scs_int *)scs_calloc((A->p[A->n]), sizeof(scs_int));
+  p->At->p = (scs_int *)scs_calloc((A->m + 1), sizeof(scs_int));
+  p->At->x = (scs_float *)scs_calloc((A->p[A->n]), sizeof(scs_float));
   transpose(A, p);
 
   /* preconditioner memory */
-  p->z = (scs_float *)scs_malloc((A->n) * sizeof(scs_float));
-  p->M = (scs_float *)scs_malloc((A->n) * sizeof(scs_float));
-  get_preconditioner(A, stgs, p);
+  p->diag_r = diag_r;
+  p->z = (scs_float *)scs_calloc(A->n, sizeof(scs_float));
+  p->M = (scs_float *)scs_calloc(A->n, sizeof(scs_float));
+  set_preconditioner(p);
 
-  p->total_solve_time = 0;
   p->tot_cg_its = 0;
   if (!p->p || !p->r || !p->Gp || !p->tmp || !p->At || !p->At->i || !p->At->p ||
       !p->At->x) {
@@ -163,94 +204,129 @@ ScsLinSysWork *SCS(init_lin_sys_work)(const ScsMatrix *A,
   return p;
 }
 
-/* solves (I+A'A)x = b, s warm start, solution stored in b */
-static scs_int pcg(const ScsMatrix *A, const ScsSettings *stgs,
-                   ScsLinSysWork *pr, const scs_float *s, scs_float *b,
+/* solves (R_x * I + P + A' R_y^{-1} A)x = b, s warm start, solution in b */
+static scs_int pcg(ScsLinSysWork *pr, const scs_float *s, scs_float *b,
                    scs_int max_its, scs_float tol) {
-  scs_int i, n = A->n;
-  scs_float ipzr, ipzr_old, alpha;
+  scs_int i, n = pr->n;
+  scs_float ztr, ztr_prev, alpha;
   scs_float *p = pr->p;   /* cg direction */
   scs_float *Gp = pr->Gp; /* updated CG direction */
   scs_float *r = pr->r;   /* cg residual */
   scs_float *z = pr->z;   /* for preconditioning */
-  scs_float *M = pr->M;   /* inverse diagonal preconditioner */
 
-  if (s == SCS_NULL) {
+  const ScsMatrix *A = pr->A;
+  const ScsMatrix *P = pr->P;
+
+  if (!s) {
+    /* take s = 0 */
+    /* r = b */
     memcpy(r, b, n * sizeof(scs_float));
+    /* b = 0 */
     memset(b, 0, n * sizeof(scs_float));
   } else {
-    mat_vec(A, stgs, pr, s, r);
-    SCS(add_scaled_array)(r, b, n, -1);
-    SCS(scale_array)(r, -1, n);
+    /* r = Mat * s */
+    mat_vec(A, P, pr, s, r);
+    /* r = Mat * s - b */
+    SCS(add_scaled_array)(r, b, n, -1.);
+    /* r = b - Mat * s */
+    SCS(scale_array)(r, -1., n);
+    /* b = s */
     memcpy(b, s, n * sizeof(scs_float));
   }
 
   /* check to see if we need to run CG at all */
-  if (SCS(norm)(r, n) < MIN(tol, 1e-18)) {
+  if (CG_NORM(r, n) < MAX(tol, 1e-12)) {
     return 0;
   }
 
-  apply_pre_conditioner(M, z, r, n, &ipzr);
+  /* z = M r (M is inverse preconditioner) */
+  apply_pre_conditioner(z, r, n, pr);
+  /* ztr = z'r */
+  ztr = SCS(dot)(z, r, n);
+  /* p = z */
   memcpy(p, z, n * sizeof(scs_float));
 
   for (i = 0; i < max_its; ++i) {
-    mat_vec(A, stgs, pr, p, Gp);
-    alpha = ipzr / SCS(dot)(p, Gp, n);
+    /* Gp = Mat * p */
+    mat_vec(A, P, pr, p, Gp);
+    /* alpha = z'r / p'G p */
+    alpha = ztr / SCS(dot)(p, Gp, n);
+    /* b += alpha * p */
     SCS(add_scaled_array)(b, p, n, alpha);
+    /* r -= alpha * G p */
     SCS(add_scaled_array)(r, Gp, n, -alpha);
 
-    if (SCS(norm)(r, n) < tol) {
-#if EXTRA_VERBOSE > 0
-      scs_printf("tol: %.4e, resid: %.4e, iters: %li\n", tol, SCS(norm)(r, n),
-                 (long)i + 1);
+#if VERBOSITY > 3
+    scs_printf("tol: %.4e, resid: %.4e, iters: %li\n", tol, CG_NORM(r, n),
+               (long)i + 1);
 #endif
+    if (CG_NORM(r, n) < tol) {
       return i + 1;
     }
-    ipzr_old = ipzr;
-    apply_pre_conditioner(M, z, r, n, &ipzr);
-
-    SCS(scale_array)(p, ipzr / ipzr_old, n);
-    SCS(add_scaled_array)(p, z, n, 1);
+    /* z = M r (M is inverse preconditioner) */
+    apply_pre_conditioner(z, r, n, pr);
+    ztr_prev = ztr;
+    /* ztr = z'r */
+    ztr = SCS(dot)(z, r, n);
+    /* p = beta * p, where beta = ztr / ztr_prev */
+    SCS(scale_array)(p, ztr / ztr_prev, n);
+    /* p = z + beta * p */
+    SCS(add_scaled_array)(p, z, n, 1.);
   }
   return i;
 }
 
-scs_int SCS(solve_lin_sys)(const ScsMatrix *A, const ScsSettings *stgs,
-                           ScsLinSysWork *p, scs_float *b, const scs_float *s,
-                           scs_int iter) {
-  scs_int cg_its;
-  SCS(timer) linsys_timer;
-  scs_float cg_tol =
-      SCS(norm)(b, A->n) *
-      (iter < 0 ? CG_BEST_TOL
-                : CG_MIN_TOL / POWF((scs_float)iter + 1, stgs->cg_rate));
-
-  SCS(tic)(&linsys_timer);
-  /* solves Mx = b, for x but stores result in b */
-  /* s contains warm-start (if available) */
-  SCS(accum_by_atrans)(A, p, &(b[A->n]), b);
-  /* solves (I+A'A)x = b, s warm start, solution stored in b */
-  cg_its = pcg(A, stgs, p, s, b, A->n, MAX(cg_tol, CG_BEST_TOL));
-  SCS(scale_array)(&(b[A->n]), -1, A->m);
-  SCS(accum_by_a)(A, p, b, &(b[A->n]));
-
-  if (iter >= 0) {
-    p->tot_cg_its += cg_its;
+/* solves Mx = b, for x but stores result in b */
+/* s contains warm-start (if available) */
+/*
+ * [x] = [R_x + P     A' ]^{-1} [rx]
+ * [y]   [   A      -R_y ]      [ry]
+ *
+ * becomes:
+ *
+ * x = (R_x + P + A' R_y^{-1} A)^{-1} (rx + A' R_y^{-1} ry)
+ * y = R_y^{-1} (Ax - ry)
+ *
+ */
+scs_int SCS(solve_lin_sys)(ScsLinSysWork *p, scs_float *b, const scs_float *s,
+                           scs_float tol) {
+  scs_int cg_its, max_iters;
+
+  if (tol <= 0.) {
+    scs_printf("Warning: tol = %4f <= 0, likely compiled without setting "
+               "INDIRECT flag.\n",
+               tol);
   }
 
-  p->total_solve_time += SCS(tocq)(&linsys_timer);
-#if EXTRA_VERBOSE > 0
-  scs_printf("linsys solve time: %1.2es\n", SCS(tocq)(&linsys_timer) / 1e3);
+  if (CG_NORM(b, p->n + p->m) <= 1e-12) {
+    memset(b, 0, (p->n + p->m) * sizeof(scs_float));
+    return 0;
+  }
+
+  /* use p->tmp here, and in mat_vec, can do both since they don't overlap */
+  /* b = [rx; ry] */
+  /* tmp = ry */
+  memcpy(p->tmp, &(b[p->n]), p->m * sizeof(scs_float));
+  /* tmp = R_y^{-1} * ry */
+  scale_by_r_y_inv(p->tmp, p);
+  /* b[:n] = rx + A' R_y^{-1} ry */
+  SCS(accum_by_atrans)(p->A, p->tmp, b);
+  /* set max_iters to 10 * n (though in theory n is enough for any tol) */
+  max_iters = 10 * p->n;
+  /* solves (R_x + P + A' R_y^{-1} A)x = b, s warm start, solution stored in
+   * b */
+  cg_its = pcg(p, s, b, max_iters, tol); /* b[:n] = x */
+
+  /* b[n:] = -ry */
+  SCS(scale_array)(&(b[p->n]), -1., p->m);
+  /* b[n:] = Ax - ry */
+  accum_by_a(p, b, &(b[p->n]));
+  /* b[n:] = R_y^{-1} (Ax - ry) = y */
+  scale_by_r_y_inv(&(b[p->n]), p);
+  p->tot_cg_its += cg_its;
+#if VERBOSITY > 1
+  scs_printf("tol %.3e\n", tol);
+  scs_printf("cg_its %i\n", (int)cg_its);
 #endif
   return 0;
 }
-
-void SCS(normalize_a)(ScsMatrix *A, const ScsSettings *stgs, const ScsCone *k,
-                      ScsScaling *scal) {
-  SCS(_normalize_a)(A, stgs, k, scal);
-}
-
-void SCS(un_normalize_a)(ScsMatrix *A, const ScsSettings *stgs,
-                         const ScsScaling *scal) {
-  SCS(_un_normalize_a)(A, stgs, scal);
-}

data/vendor/scs/linsys/cpu/indirect/private.h

@@ -5,24 +5,27 @@
 extern "C" {
 #endif
 
-#include <math.h>
-#include "amatrix.h"
 #include "glbopts.h"
 #include "linalg.h"
 #include "scs.h"
+#include "scs_matrix.h"
+#include <math.h>
 
 struct SCS_LIN_SYS_WORK {
+  scs_int n, m; /* linear system dimensions */
   scs_float *p; /* cg iterate  */
   scs_float *r; /* cg residual */
   scs_float *Gp;
   scs_float *tmp;
-  ScsMatrix *At;
+  const ScsMatrix *A; /* does *not* own this memory */
+  const ScsMatrix *P; /* does *not* own this memory */
+  ScsMatrix *At;      /* does own this memory */
   /* preconditioning */
   scs_float *z;
   scs_float *M;
   /* reporting */
   scs_int tot_cg_its;
-  scs_float total_solve_time;
+  const scs_float *diag_r;
 };
 
 #ifdef __cplusplus

data/vendor/scs/linsys/csparse.c

@@ -0,0 +1,87 @@
+/* Routines modified from CSparse, T. Davis et al */
+
+#include "csparse.h"
+
+csc *SCS(cs_spalloc)(scs_int m, scs_int n, scs_int nzmax, scs_int values,
+                     scs_int triplet) {
+  csc *A = (csc *)scs_calloc(1, sizeof(csc)); /* allocate the csc struct */
+  if (!A) {
+    return SCS_NULL;
+  }         /* out of memory */
+  A->m = m; /* define dimensions and nzmax */
+  A->n = n;
+  A->nzmax = nzmax = MAX(nzmax, 1);
+  A->nz = triplet ? 0 : -1; /* allocate triplet or comp.col */
+  A->p = (scs_int *)scs_calloc((triplet ? nzmax : n + 1), sizeof(scs_int));
+  A->i = (scs_int *)scs_calloc(nzmax, sizeof(scs_int));
+  A->x = values ? (scs_float *)scs_calloc(nzmax, sizeof(scs_float)) : SCS_NULL;
+  return (!A->p || !A->i || (values && !A->x)) ? SCS(cs_spfree)(A) : A;
+}
+
+csc *SCS(cs_done)(csc *C, void *w, void *x, scs_int ok) {
+  scs_free(w); /* free workspace */
+  scs_free(x);
+  return ok ? C : SCS(cs_spfree)(C); /* return result if OK, else free it */
+}
+
+/* C = compressed-column form of a triplet matrix T */
+csc *SCS(cs_compress)(const csc *T, scs_int *idx_mapping) {
+  scs_int m, n, nz, p, k, *Cp, *Ci, *w, *Ti, *Tj;
+  scs_float *Cx, *Tx;
+  csc *C;
+  m = T->m;
+  n = T->n;
+  Ti = T->i;
+  Tj = T->p;
+  Tx = T->x;
+  nz = T->nz;
+  C = SCS(cs_spalloc)(m, n, nz, Tx != SCS_NULL, 0); /* allocate result */
+  w = (scs_int *)scs_calloc(n, sizeof(scs_int));    /* get workspace */
+  if (!C || !w) {
+    return SCS(cs_done)(C, w, SCS_NULL, 0);
+  } /* out of memory */
+  Cp = C->p;
+  Ci = C->i;
+  Cx = C->x;
+  for (k = 0; k < nz; k++) {
+    w[Tj[k]]++; /* column counts */
+  }
+  SCS(cumsum)(Cp, w, n); /* column pointers */
+  for (k = 0; k < nz; k++) {
+    Ci[p = w[Tj[k]]++] = Ti[k]; /* A(i,j) is the pth entry in C */
+    if (idx_mapping) {
+      idx_mapping[k] = p;
+    } /* old to new indices */
+    if (Cx) {
+      Cx[p] = Tx[k];
+    }
+  }
+  return SCS(cs_done)(C, w, SCS_NULL, 1); /* success; free w and return C */
+}
+
+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]) */
+}
+
+csc *SCS(cs_spfree)(csc *A) {
+  if (!A) {
+    return SCS_NULL;
+  } /* do nothing if A already SCS_NULL */
+  scs_free(A->p);
+  scs_free(A->i);
+  scs_free(A->x);
+  scs_free(A);
+  return (csc *)SCS_NULL; /* free the csc struct and return SCS_NULL */
+}

data/vendor/scs/linsys/csparse.h

@@ -0,0 +1,34 @@
+/* Routines modified from CSparse, T. Davis et al */
+
+#ifndef CS_H_GUARD
+#define CS_H_GUARD
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "glbopts.h"
+#include "scs.h"
+
+/* matrix in compressed-column or triplet form */
+typedef struct SPARSE_MATRIX {
+  scs_int nzmax; /* maximum number of entries */
+  scs_int m;     /* number of rows */
+  scs_int n;     /* number of columns */
+  scs_int *p;    /* column pointers (size n+1) or col indices (size nzmax) */
+  scs_int *i;    /* row indices, size nzmax */
+  scs_float *x;  /* numerical values, size nzmax */
+  scs_int nz;    /* # of entries in triplet matrix, -1 for compressed-col */
+} csc;
+
+csc *SCS(cs_spalloc)(scs_int m, scs_int n, scs_int nzmax, scs_int values,
+                     scs_int triplet);
+csc *SCS(cs_done)(csc *C, void *w, void *x, scs_int ok);
+csc *SCS(cs_compress)(const csc *T, scs_int *idx_mapping);
+scs_float SCS(cumsum)(scs_int *p, scs_int *c, scs_int n);
+csc *SCS(cs_spfree)(csc *A);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

data/vendor/scs/linsys/external/amd/SuiteSparse_config.c

@@ -18,7 +18,6 @@
 
 #ifdef MATLAB_MEX_FILE
 #include "mex.h"
-#include "matrix.h"
 #endif
 
 #ifndef NULL
@@ -51,7 +50,7 @@
 
 struct SuiteSparse_config_struct SuiteSparse_config =
 {
-    _scs_malloc, _scs_calloc, _scs_realloc, _scs_free, _scs_printf,
+    scs_malloc, scs_calloc, scs_realloc, scs_free, _scs_printf,
     SuiteSparse_hypot,
     SuiteSparse_divcomplex
 
@@ -73,12 +72,13 @@ struct SuiteSparse_config_struct SuiteSparse_config =
    SuiteSparse_start be called prior to calling any SuiteSparse function.
  */
 
+
 void SuiteSparse_start ( void )
 {
-    SuiteSparse_config.malloc_func  = _scs_malloc ;
-    SuiteSparse_config.calloc_func  = _scs_calloc ;
-    SuiteSparse_config.realloc_func = _scs_realloc ;
-    SuiteSparse_config.free_func    = _scs_free ;
+    SuiteSparse_config.malloc_func  = scs_malloc ;
+    SuiteSparse_config.calloc_func  = scs_calloc ;
+    SuiteSparse_config.realloc_func = scs_realloc ;
+    SuiteSparse_config.free_func    = scs_free ;
     SuiteSparse_config.printf_func  = _scs_printf ;
     /* math functions */
     SuiteSparse_config.hypot_func = SuiteSparse_hypot ;

data/vendor/scs/linsys/external/amd/SuiteSparse_config.h

@@ -44,7 +44,7 @@ extern "C" {
 
 #include <limits.h>
 #include <stdlib.h>
-#include "scs.h"
+#include "glbopts.h"
 #include "ctrlc.h"
 
 /* ========================================================================== */
@@ -71,6 +71,11 @@ extern "C" {
 #define SuiteSparse_long_id "%" SuiteSparse_long_idd
 #endif
 
+#ifndef _scs_printf
+#define _scs_printf scs_printf
+#endif
+
+
 /* ========================================================================== */
 /* === SuiteSparse_config parameters and functions ========================== */
 /* ========================================================================== */

data/vendor/scs/linsys/external/amd/amd_internal.h

@@ -66,7 +66,7 @@
 /* ------------------------------------------------------------------------- */
 
 #ifdef MATLAB_MEX_FILE
-#include "matrix.h"
+#include "scs_matrix.h"
 #include "mex.h"
 #endif
 

data/vendor/scs/linsys/external/amd/amd_order.c

@@ -89,8 +89,8 @@ GLOBAL Int AMD_order
     }
 
     /* allocate two size-n integer workspaces */
-    Len  = SuiteSparse_malloc (n, sizeof (Int)) ;
-    Pinv = SuiteSparse_malloc (n, sizeof (Int)) ;
+    Len  = (Int *)SuiteSparse_malloc (n, sizeof (Int)) ;
+    Pinv = (Int *)SuiteSparse_malloc (n, sizeof (Int)) ;
     mem += n ;
     mem += n ;
     if (!Len || !Pinv)
@@ -106,8 +106,8 @@ GLOBAL Int AMD_order
     {
 	/* sort the input matrix and remove duplicate entries */
 	AMD_DEBUG1 (("Matrix is jumbled\n")) ;
-	Rp = SuiteSparse_malloc (n+1, sizeof (Int)) ;
-	Ri = SuiteSparse_malloc (nz,  sizeof (Int)) ;
+	Rp = (Int *)SuiteSparse_malloc (n+1, sizeof (Int)) ;
+	Ri = (Int *)SuiteSparse_malloc (nz,  sizeof (Int)) ;
 	mem += (n+1) ;
 	mem += MAX (nz,1) ;
 	if (!Rp || !Ri)
@@ -160,7 +160,7 @@ GLOBAL Int AMD_order
     ok = ok && (slen < Int_MAX) ;	/* S[i] for Int i must be OK */
     if (ok)
     {
-	S = SuiteSparse_malloc (slen, sizeof (Int)) ;
+	S = (Int *)SuiteSparse_malloc (slen, sizeof (Int)) ;
     }
     AMD_DEBUG1 (("slen %g\n", (scs_float) slen)) ;
     if (!S)