scs 0.5.1 → 0.5.2

data/vendor/scs/src/spectral_cones/nuclear/ell1_cone.c

@@ -0,0 +1,221 @@
+#include "cones.h"
+// #include "scs.h"
+#include "linalg.h"
+#include "scs_blas.h"
+#include "scs_types.h"
+#include "util.h" // just for timer
+#include "util_spectral_cones.h"
+#include <stdlib.h> // qsort
+
+/*
+ * Spectral matrix cone projections, from "Projection onto Spectral Matrix
+ * Cones" by Daniel Cederberg and Stephen Boyd, 2024.
+ *
+ * If you have any questions on the code, please reach out to the code author
+ * Daniel Cederberg.
+ *
+ * This file implements code for projecting onto the ell1-norm cone.
+ *
+ * Last modified: 25 August 2024.
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void BLAS(axpy)(blas_int *n, const scs_float *a, const scs_float *x,
+                blas_int *incx, scs_float *y, blas_int *incy);
+
+scs_float BLAS(dot)(const blas_int *n, const scs_float *x, const blas_int *incx,
+                    const scs_float *y, const blas_int *incy);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifdef SPECTRAL_DEBUG
+static void compute_cone_residuals_ell1(const scs_float *tx, scs_float t0,
+                                        const scs_float *x0, scs_int n,
+                                        scs_float residuals[3]) {
+  scs_float dual_res, pri_res, complementarity;
+
+  // -------------------------------------
+  //      Compute Lagrange multiplier.
+  // (This function is not used in production so it is fine to allocate
+  // memory here)
+  // -------------------------------------
+  scs_float dualt = tx[0] - t0;
+  scs_float *dualx = malloc(n * sizeof(scs_float));
+  memcpy(dualx, tx + 1, n * sizeof(scs_float));
+  blas_int int_n = n;
+  scs_float negOne = -1.0;
+  blas_int one = 1;
+  BLAS(axpy)(&int_n, &negOne, x0, &one, dualx, &one);
+
+  // ---------------------------------------
+  //     Compute complementarity measure
+  // ---------------------------------------
+  complementarity =
+      tx[0] * dualt + BLAS(dot)(&int_n, dualx, &one, tx + 1, &one);
+
+  // -----------------------------------------------
+  //   Compute primal feasibility measure
+  // -----------------------------------------------
+  scs_float ell1_norm = 0;
+  for (const scs_float *xi = tx + 1; xi < tx + 1 + n; ++xi) {
+    ell1_norm += fabs(*xi);
+  }
+  pri_res = ell1_norm - tx[0];
+
+  // ---------------------------------------
+  //   Compute dual feasibility measure
+  // ---------------------------------------
+  scs_float inf_norm = 0;
+  for (scs_int i = 0; i < n; ++i) {
+    scs_float abs_val = fabs(dualx[i]);
+    if (abs_val > inf_norm) {
+      inf_norm = abs_val;
+    }
+  }
+  dual_res = inf_norm - dualt;
+
+  // ------------------------------------------
+  //  Assign result and free allocated memory
+  // ------------------------------------------
+  residuals[0] = dual_res;
+  residuals[1] = pri_res;
+  residuals[2] = complementarity;
+  free(dualx);
+}
+#endif
+
+// Asssumes that all components of x0 are positive and
+// x0[0] >= x0[1] >= ... x0[n-1].
+scs_int ell1_cone_proj_sorted(scs_float t0, const scs_float *x0,
+                              scs_float *proj, scs_int n) {
+  if (-t0 >= x0[0]) {
+    memset(proj, 0, (n + 1) * sizeof(*x0));
+    return 0;
+  }
+
+  // -------------------------------------------
+  //            Find the value on k
+  // -------------------------------------------
+
+  // check if k = 0 suffices
+  if (-t0 >= x0[0]) {
+    memset(proj, 0, (n + 1) * sizeof(*x0));
+    return 0;
+  }
+
+  scs_float xSum = 0;
+  scs_float tempSum = 0;
+  int k = -1;
+  for (scs_int kk = 1; kk < n; ++kk) {
+    xSum += x0[kk - 1];
+    tempSum = (-t0 + xSum) / (kk + 1);
+
+    if (x0[kk - 1] > tempSum && x0[kk] <= tempSum) {
+      k = (int)kk;
+      break;
+    }
+  }
+
+  if (k == -1) {
+    k = n;
+    xSum += x0[n - 1];
+  }
+
+  // ---------------------------------------------
+  //                Execute projection
+  // ---------------------------------------------
+  proj[0] = -t0 + xSum;
+
+  if (proj[0] > 0) {
+    proj[0] = t0 + proj[0] / (k + 1);
+  } else {
+    proj[0] = t0;
+  }
+
+  memcpy(proj + 1, x0, k * sizeof(*x0));
+  scs_float diff = proj[0] - t0;
+  for (int i = 1; i < k + 1; i++) {
+    proj[i] -= diff;
+  }
+  memset(proj + 1 + k, 0, (n - k) * sizeof(*x0));
+
+#ifdef SPECTRAL_DEBUG
+  //-------------------------------------------------------------------------
+  //               Check residuals - not needed in production
+  //-------------------------------------------------------------------------
+  scs_float residuals[3];
+  compute_cone_residuals_ell1(proj, t0, x0, n, residuals);
+
+  if (residuals[0] > 1e-8 || residuals[1] > 1e-8 || residuals[2] > 1e-8) {
+    scs_printf("WARN: something is wrong in nuclear norm cone projection.\n");
+    scs_printf("dual_res / primal_res / comp : %.3e, %.3e, %.3e\n",
+               residuals[0], residuals[1], residuals[2]);
+    return -1;
+  }
+#endif
+
+  return 0;
+}
+
+static void in_place_shuffle_ell1(scs_float *x, Value_index *work, scs_int n) {
+  for (scs_int i = 0; i < n; ++i) {
+    while (work[i].index != i) {
+      // Swap elements in `x`
+      scs_int target_idx = work[i].index;
+      scs_float temp_x = x[i];
+      x[i] = x[target_idx];
+      x[target_idx] = temp_x;
+
+      // Swap indices in `idxs` to reflect the change
+      scs_int temp_idx = work[i].index;
+      work[i].index = work[target_idx].index;
+      work[target_idx].index = temp_idx;
+    }
+  }
+}
+
+int custom_cmp(const void *a, const void *b) {
+  Value_index *elemA = (Value_index *)a;
+  Value_index *elemB = (Value_index *)b;
+  return fabs(elemB->value) - fabs(elemA->value) > 0 ? 1 : -1;
+}
+
+void SCS(proj_ell_one)(scs_float *tx, scs_int n, ScsConeWork *c) {
+  scs_float t0 = tx[0];
+  scs_float *x0 = tx + 1;
+  scs_float *proj = c->work_ell1_proj;
+  Value_index *work = c->work_ell1;
+  // ------------------------------------------------------
+  //     Preprocess vector so it is nonnegative and sorted
+  // ------------------------------------------------------
+  for (scs_int i = 0; i < n; ++i) {
+    work[i].value = fabs(x0[i]);
+    work[i].index = i;
+  }
+
+  qsort(work, n, sizeof(Value_index), custom_cmp);
+
+  for (scs_int i = 0; i < n; ++i) {
+    proj[i + 1] = work[i].value;
+  }
+
+  // ------------------------------------------
+  //        project preprocessed vector
+  // ------------------------------------------
+  ell1_cone_proj_sorted(t0, proj + 1, proj, n);
+
+  // -------------------------------------------
+  //        recover original vector
+  // -------------------------------------------
+  in_place_shuffle_ell1(proj + 1, work, n);
+  for (scs_int i = 0; i < n; i++) {
+    proj[i + 1] = proj[i + 1] * (x0[i] >= 0 ? 1 : -1);
+  }
+
+  memcpy(tx, proj, (n + 1) * sizeof(*proj));
+}

data/vendor/scs/src/spectral_cones/nuclear/nuclear_cone.c

@@ -0,0 +1,99 @@
+#include "cones.h"
+// #include "scs.h"
+#include "linalg.h"
+#include "scs_blas.h"
+#include "scs_types.h"
+#include "util.h" // just for timer
+
+/*
+ * Spectral matrix cone projections, from "Projection onto Spectral Matrix
+ * Cones" by Daniel Cederberg and Stephen Boyd, 2024.
+ *
+ * If you have any questions on the code, please reach out to the code author
+ * Daniel Cederberg.
+ *
+ * This file implements code for projecting onto the nuclear norm cone.
+ *
+ * Last modified: 25 August 2024.
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void BLAS(gemm)(const char *transa, const char *transb, blas_int *m,
+                blas_int *n, blas_int *k, scs_float *alpha, scs_float *a,
+                blas_int *lda, scs_float *b, blas_int *ldb, scs_float *beta,
+                scs_float *c, blas_int *ldc);
+
+void BLAS(scal)(const blas_int *n, const scs_float *sa, scs_float *sx,
+                const blas_int *incx);
+
+void BLAS(gesvd)(const char *jobu, const char *jobvt, const blas_int *m,
+                 const blas_int *n, scs_float *a, const blas_int *lda,
+                 scs_float *s, scs_float *u, const blas_int *ldu, scs_float *vt,
+                 const blas_int *ldvt, scs_float *work, const blas_int *lwork,
+                 blas_int *info);
+
+#ifdef __cplusplus
+}
+#endif
+
+// forward declaration from ell1_cone.c
+scs_int ell1_cone_proj_sorted(scs_float t0, const scs_float *x0,
+                              scs_float *proj, scs_int n);
+
+// X is of size m x n, stored column major. It is assumed that m >= n.
+scs_int SCS(proj_nuclear_cone)(scs_float *tX, scs_int m, scs_int n,
+                               ScsConeWork *c) {
+  assert(m >= n);
+  scs_float *X = tX + 1;
+  blas_int bm = m;
+  blas_int bn = n;
+
+  // -------------------------------------------------------------------------
+  //                            Compute SVD
+  // -------------------------------------------------------------------------
+  scs_float *s = c->s_nuc;
+  scs_float *u = c->u_nuc;
+  scs_float *vt = c->vt_nuc;
+
+  scs_float *work = c->work_nuc;
+  int lwork = c->lwork_nuc;
+  int info = 0;
+
+  BLAS(gesvd)("S", "A", &bm, &bn, X, &bm, s, u, &bm, vt, &bn, work, &lwork,
+              &info);
+  if (info != 0) {
+    printf("WARN: LAPACK gesvd error, info = %i\n", (int)info);
+    if (info < 0) {
+      return info;
+    }
+  }
+  // -------------------------------------------------------------------------
+  //                  Project onto spectral *vector* cone
+  // -------------------------------------------------------------------------
+  SPECTRAL_TIMING(SCS(timer) _timer; SCS(tic)(&_timer);)
+  scs_int status = ell1_cone_proj_sorted(tX[0], s, tX, n);
+  SPECTRAL_TIMING(c->tot_time_vec_cone_proj += SCS(tocq)(&_timer);)
+
+  if (status < 0) {
+    return status;
+  }
+
+  // -------------------------------------------------------------------------
+  //  Recover projection onto spectral *matrix* cone
+  // -------------------------------------------------------------------------
+  int one = 1;
+  for (scs_int i = 0; i < n; ++i) {
+    BLAS(scal)(&bm, &tX[i + 1], &u[i * m], &one);
+  }
+
+  char trans = 'N';
+  scs_float alpha = 1.0;
+  scs_float beta = 0.0;
+  BLAS(gemm)(&trans, &trans, &bm, &bn, &bn, &alpha, u, &bm, vt, &bn, &beta,
+             tX + 1, &bm);
+
+  return 0;
+}

data/vendor/scs/src/spectral_cones/sum-largest/sum_largest_cone.c

@@ -0,0 +1,196 @@
+#include "cones.h"
+// #include "scs.h"
+#include "linalg.h"
+#include "scs_blas.h"
+#include "scs_types.h"
+#include "util_spectral_cones.h"
+#include <stdlib.h> // qsort
+
+#define TOL_LARGEST_CONE 1e-9
+
+/*
+ * Spectral matrix cone projections, from "Projection onto Spectral Matrix
+ * Cones" by Daniel Cederberg and Stephen Boyd, 2024.
+ *
+ * If you have any questions on the code, please reach out to the code author
+ * Daniel Cederberg.
+ *
+ * This file implements code for projecting onto the sum-of-largest cone.
+ * It assumes that the input is sorted. If you need code that does not make
+ * this assumption, please reach out.
+ *
+ * Last modified: 25 August 2024.
+ */
+
+#ifdef SPECTRAL_DEBUG
+static void compute_cone_residuals(scs_float t, const scs_float *x,
+                                   scs_float t0, const scs_float *x0,
+                                   scs_float residuals[3], scs_int n,
+                                   scs_int k);
+#endif
+
+scs_int assert_sorted(scs_float *x, scs_int n) {
+  for (scs_int i = 0; i < n - 1; ++i) {
+    if (x[i] < x[i + 1]) {
+      return -1;
+    }
+  }
+  return 0;
+}
+
+scs_int proj_sum_largest_cone_sorted(scs_float *t, scs_float *x, scs_int n,
+                                     scs_int k) {
+#ifdef SPECTRAL_DEBUG
+  scs_float t00 = *t;
+  scs_float *x0 = scs_malloc(n * sizeof(*x0));
+  memcpy(x0, x, n * sizeof(*x0));
+  scs_int status = assert_sorted(x, n);
+  if (status < 0) {
+    scs_printf("NOT SORTED! \n");
+    return status;
+  }
+#endif
+
+  // -------------------------------
+  //    Initialize state variables
+  // -------------------------------
+  assert(k < n && k > 0);
+  scs_int nu = k, nt = 0;
+  scs_float eta = 0.0;
+  scs_float t0 = *t;
+  scs_float S = x[0];
+  for (scs_int i = 1; i < k; ++i) {
+    S += x[i];
+  }
+
+  scs_float a_u = x[nu - 1], a_t = x[nu];
+
+  // ---------------------------------
+  //           main loop
+  // ---------------------------------
+  scs_float ratio, s1, s3, s;
+  while (S > *t + TOL_LARGEST_CONE) {
+    ratio = (nu == k) ? 1.0 : (scs_float)(nt) / (k - nu);
+
+    // ------------------------------------------------------
+    //                 compute step size
+    // ------------------------------------------------------
+    s1 = (nu == k) ? a_u - a_t : (a_u - a_t) / (ratio - 1);
+    s3 = (S - *t) / (ratio * (nu + 1) + (k - nu));
+    s = (nu == 0) ? s3 : MIN(s3, s1);
+
+    if (!(nu + nt == n || nt == 0)) {
+      scs_float val = a_t - x[nu + nt];
+      s = MIN(s, val);
+    }
+
+    // --------------------------
+    //        update state
+    // --------------------------
+    eta += s * ratio;
+    S -= s * (ratio * nu + k - nu);
+    *t = t0 + eta;
+
+    if (nt > 0) {
+      a_t -= s;
+    }
+
+    if (nu != 0 && s == s1) {
+      nu -= 1;
+    } else {
+      assert(s != s1);
+    }
+
+    if (nu > 0) {
+      a_u = x[nu - 1] - eta;
+    }
+
+    nt = (nt == 0) ? 2 : nt + 1;
+  }
+
+  nt -= 1;
+
+  // update projection
+  scs_int i;
+  for (i = 0; i < nu; ++i) {
+    x[i] -= eta;
+  }
+
+  for (i = nu; i < nu + nt; ++i) {
+    x[i] = a_t;
+  }
+
+#ifdef SPECTRAL_DEBUG
+  scs_float residuals[3];
+  compute_cone_residuals(*t, x, t00, x0, residuals, n, k);
+  scs_free(x0);
+  if (residuals[0] > 1e-10 || residuals[1] > 1e-10 ||
+      fabs(residuals[2]) > 1e-10) {
+    return -1;
+  }
+#endif
+
+  return 0;
+}
+
+scs_int cmp_desc(const void *a, const void *b) {
+  scs_float da = *(const scs_float *)a;
+  scs_float db = *(const scs_float *)b;
+  if (da < db)
+    return 1;
+  if (da > db)
+    return -1;
+  return 0;
+}
+
+#ifdef SPECTRAL_DEBUG
+// this function is not used in production so fine to allocate memory
+static scs_float sum_largest_val(const scs_float *x, scs_int n, scs_int k) {
+  scs_float *x_temp = scs_malloc(n * sizeof(*x));
+  memcpy(x_temp, x, n * sizeof(*x));
+  qsort(x_temp, n, sizeof(*x_temp), cmp_desc);
+
+  scs_float val = 0.0;
+  for (scs_int i = 0; i < k; ++i) {
+    val += x_temp[i];
+  }
+  scs_free(x_temp);
+  return val;
+}
+
+static void compute_cone_residuals(scs_float t, const scs_float *x,
+                                   scs_float t0, const scs_float *x0,
+                                   scs_float residuals[3], scs_int n,
+                                   scs_int k) {
+  scs_float lmbda_t = t - t0;
+  scs_float *lmbda_x = scs_malloc(n * sizeof(*x));
+  scs_float sum_lmbda_x = 0.0;
+  for (scs_int i = 0; i < n; ++i) {
+    lmbda_x[i] = x[i] - x0[i];
+    sum_lmbda_x += lmbda_x[i];
+  }
+
+  scs_float comp = lmbda_t * t + SCS(dot)(lmbda_x, x, n);
+  scs_float pri_res = sum_largest_val(x, n, k) - t;
+
+  scs_float dual_res = fabs(sum_lmbda_x + lmbda_t * k);
+  dual_res *= dual_res;
+
+  for (scs_int i = 0; i < n; ++i) {
+    if (lmbda_x[i] > 0) {
+      dual_res += lmbda_x[i] * lmbda_x[i];
+    }
+
+    if (lmbda_x[i] + lmbda_t < 0) {
+      dual_res += (lmbda_x[i] + lmbda_t) * (lmbda_x[i] + lmbda_t);
+    }
+  }
+
+  residuals[0] = dual_res;
+  residuals[1] = pri_res;
+  residuals[2] = comp;
+
+  scs_free(lmbda_x);
+}
+#endif
+

data/vendor/scs/src/spectral_cones/sum-largest/sum_largest_eval_cone.c

@@ -0,0 +1,140 @@
+#include "cones.h"
+#include "linalg.h"
+#include "scs_blas.h"
+#include "scs_types.h"
+#include "util.h" // just for timer
+
+/*
+ * Spectral matrix cone projections, from "Projection onto Spectral Matrix
+ * Cones" by Daniel Cederberg and Stephen Boyd, 2024.
+ *
+ * If you have any questions on the code, please reach out to the code author
+ * Daniel Cederberg.
+ *
+ * This file implements code for projecting onto the sum-of-largest eigenvalues
+ * cone.
+ *
+ * Last modified: 25 August 2024.
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void BLAS(syev)(const char *jobz, const char *uplo, blas_int *n, scs_float *a,
+                blas_int *lda, scs_float *w, scs_float *work, blas_int *lwork,
+                blas_int *info);
+
+void BLAS(scal)(const blas_int *n, const scs_float *sa, scs_float *sx,
+                const blas_int *incx);
+
+void BLAS(gemm)(const char *transa, const char *transb, blas_int *m,
+                blas_int *n, blas_int *k, scs_float *alpha, scs_float *a,
+                blas_int *lda, scs_float *b, blas_int *ldb, scs_float *beta,
+                scs_float *c, blas_int *ldc);
+
+#ifdef __cplusplus
+}
+#endif
+
+// forward declaration
+scs_int proj_sum_largest_cone_sorted(scs_float *t, scs_float *x, scs_int n,
+                                     scs_int k);
+
+void flip(scs_float *x, int n) {
+  scs_float temp;
+  for (int i = 0; i < n / 2; i++) {
+    temp = x[i];
+    x[i] = x[n - i - 1];
+    x[n - i - 1] = temp;
+  }
+}
+
+scs_int SCS(proj_sum_largest_evals)(scs_float *tX, scs_int n, scs_int k,
+                                    ScsConeWork *c) {
+  // tvX = [t, X], where X represents the lower triangular part of a matrix
+  // stored in a compact form and off-diagonal elements have been scaled by
+  // sqrt(2)
+  scs_float *X = tX + 1;
+
+  // ----------------------------------------------------------------------
+  //                      compute eigendecomposition
+  // ----------------------------------------------------------------------
+  scs_int i;
+  blas_int nb = (blas_int)n;
+  blas_int nb_plus_one = (blas_int)(n + 1);
+  blas_int one_int = 1;
+  scs_float sqrt2 = sqrt(2.0);
+  scs_float sqrt2_inv = 1.0 / sqrt2;
+  scs_float *Xs = c->Xs;
+  scs_float *e = c->e;
+  scs_float *Z = c->Z;
+  scs_float *work = c->work;
+  blas_int lwork = c->lwork;
+  blas_int info = 0;
+
+  // copy lower triangular matrix into full matrix
+  for (i = 0; i < n; ++i) {
+    memcpy(&(Xs[i * (n + 1)]), &(X[i * n - ((i - 1) * i) / 2]),
+           (n - i) * sizeof(scs_float));
+  }
+
+  // rescale diags by sqrt(2)
+  BLAS(scal)(&nb, &sqrt2, Xs, &nb_plus_one);
+
+  // Eigendecomposition. On exit, the lower triangular part of Xs stores
+  // the eigenvectors. The vector e stores the eigenvalues in ascending
+  // order (smallest eigenvalue first) */
+  BLAS(syev)("Vectors", "Lower", &nb, Xs, &nb, e, work, &lwork, &info);
+  if (info != 0) {
+    scs_printf("WARN: LAPACK syev error, info = %i\n", (int)info);
+    if (info < 0) {
+      return info;
+    }
+  }
+
+  // ----------------------------------------------------------------------
+  //  Project onto spectral *vector* cone. Note that e is sqrt(2) times
+  //  the eigenvalue vector we want to project. We therefore multiply
+  //  tvX[0] by sqrt(2).
+  // ----------------------------------------------------------------------
+  tX[0] *= sqrt2;
+  SPECTRAL_TIMING(SCS(timer) _timer; SCS(tic)(&_timer);)
+  flip(e, n);
+  scs_int status = proj_sum_largest_cone_sorted(&tX[0], e, n, k);
+  flip(e, n);
+  SPECTRAL_TIMING(c->tot_time_vec_cone_proj += SCS(tocq)(&_timer);)
+
+  if (status < 0) {
+    return status;
+  }
+
+  // ----------------------------------------------------------------------
+  //             recover projection onto spectral *matrix* cone
+  // ----------------------------------------------------------------------
+  memcpy(c->work_sum_of_largest, Xs, n * n * sizeof(*Xs));
+  for (i = 0; i < n; ++i) {
+    BLAS(scal)(&nb, &e[i], &Xs[i * n], &one_int);
+  }
+
+  char transN = 'N';
+  char transY = 'T';
+  scs_float one = 1.0;
+  scs_float zero = 0.0;
+
+  // it is not safe to have overlapping matrices for dgemm_.
+  BLAS(gemm)(&transN, &transY, &nb, &nb, &nb, &one, Xs, &nb,
+             c->work_sum_of_largest, &nb, &zero, Z, &nb);
+
+  BLAS(scal)(&nb, &sqrt2_inv, Z, &nb_plus_one);
+
+  for (i = 0; i < n; ++i) {
+    memcpy(&(X[i * n - ((i - 1) * i) / 2]), &(Z[i * (n + 1)]),
+           (n - i) * sizeof(scs_float));
+  }
+
+  tX[0] *= sqrt2_inv;
+
+  return 0;
+}
+

data/vendor/scs/src/spectral_cones/util_spectral_cones.c

@@ -0,0 +1,52 @@
+#include "util_spectral_cones.h"
+
+bool is_pos(const scs_float *x, scs_int n) {
+  for (scs_int i = 0; i < n; ++i) {
+    if (x[i] <= 0.0) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool is_negative(const scs_float *x, scs_int n) {
+  for (scs_int i = 0; i < n; ++i) {
+    if (x[i] >= 0.0) {
+      return false;
+    }
+  }
+  return true;
+}
+
+void non_neg_proj(const scs_float *src, scs_float *dst, scs_int n) {
+  for (scs_int i = 0; i < n; ++i) {
+    dst[i] = (src[i] > 0.0) ? src[i] : 0.0;
+  }
+}
+
+void print_vector(const scs_float *x, scs_int n) {
+  for (scs_int i = 0; i < n; ++i) {
+    printf("%f ", x[i]);
+  }
+  printf("\n");
+}
+
+scs_float min_vec(const scs_float *vec, scs_int n) {
+  scs_float minVal = vec[0];
+
+  for (scs_int i = 1; i < n; ++i) {
+    if (vec[i] < minVal) {
+      minVal = vec[i];
+    }
+  }
+
+  return minVal;
+}
+
+scs_float sum_log(const scs_float *x, scs_int n) {
+  scs_float sum = 0.0;
+  for (scs_int i = 0; i < n; ++i) {
+    sum += log(x[i]);
+  }
+  return sum;
+}