casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/highs/qpsolver/feasibility_highs.hpp

@@ -0,0 +1,270 @@
+#ifndef __SRC_LIB_FEASIBILITYHIGHS_HPP__
+#define __SRC_LIB_FEASIBILITYHIGHS_HPP__
+
+#include "Highs.h"
+#include "qpsolver/a_asm.hpp"
+#include "qpsolver/crashsolution.hpp"
+
+static void computeStartingPointHighs(Instance& instance,
+				      Settings& settings,
+				      Statistics& stats,
+				      QpModelStatus& modelstatus,
+				      QpHotstartInformation& result,
+				      HighsModelStatus& highs_model_status,
+				      HighsBasis& highs_basis,
+				      HighsSolution& highs_solution,
+				      HighsTimer& timer) {
+  bool have_starting_point = false;
+  const bool debug_report = false;
+  if (highs_solution.value_valid) {
+    // #1350 add primal_feasibility_tolerance to settings
+    const double primal_feasibility_tolerance = settings.lambda_zero_threshold;
+
+    HighsInt num_var_infeasibilities = 0;
+    double max_var_infeasibility = 0;
+    double sum_var_infeasibilities = 0;
+    HighsInt num_con_infeasibilities = 0;
+    double max_con_infeasibility = 0;
+    double sum_con_infeasibilities = 0;
+    double max_con_residual = 0;
+    double sum_con_residuals = 0;
+     
+    assessQpPrimalFeasibility(instance, primal_feasibility_tolerance,
+			      highs_solution.col_value, highs_solution.row_value,
+			      num_var_infeasibilities, max_var_infeasibility, sum_var_infeasibilities,
+			      num_con_infeasibilities, max_con_infeasibility, sum_con_infeasibilities,
+			      max_con_residual, sum_con_residuals);
+
+    if (debug_report) printf("computeStartingPointHighs highs_solution has (num / max / sum) "
+	   "var (%d / %g / %g) and "
+	   "con (%d / %g / %g) infeasibilities "
+	   "with (max = %g; sum = %g) residuals\n",
+	   int(num_var_infeasibilities), max_var_infeasibility, sum_var_infeasibilities,
+	   int(num_con_infeasibilities), max_con_infeasibility, sum_con_infeasibilities,
+	   max_con_residual, sum_con_residuals);
+    have_starting_point = 
+      num_var_infeasibilities == 0 &&
+      num_con_infeasibilities == 0 &&
+      highs_basis.valid;
+  }
+  // compute initial feasible point
+  HighsBasis use_basis;
+  HighsSolution use_solution;
+  if (have_starting_point) {
+    use_basis = highs_basis;
+    use_solution = highs_solution;
+  } else {
+    Highs highs;
+
+    // set HiGHS to be silent
+    highs.setOptionValue("output_flag", false);
+
+    highs.setOptionValue("presolve", "on");
+
+    highs.setOptionValue("time_limit", settings.time_limit -
+			 timer.readRunHighsClock());
+
+    HighsLp lp;
+    lp.a_matrix_.index_ = instance.A.mat.index;
+    lp.a_matrix_.start_ = instance.A.mat.start;
+    lp.a_matrix_.value_ = instance.A.mat.value;
+    lp.a_matrix_.format_ = MatrixFormat::kColwise;
+    lp.col_cost_.assign(instance.num_var, 0.0);
+    // lp.col_cost_ = runtime.instance.c.value;
+    lp.col_lower_ = instance.var_lo;
+    lp.col_upper_ = instance.var_up;
+    lp.row_lower_ = instance.con_lo;
+    lp.row_upper_ = instance.con_up;
+    lp.num_col_ = instance.num_var;
+    lp.num_row_ = instance.num_con;
+
+    // create artificial bounds for free variables: false by default
+    assert(!settings.phase1boundfreevars);
+    if (settings.phase1boundfreevars) {
+      for (HighsInt i=0; i<instance.num_var; i++) {
+	if (isfreevar(instance, i)) {
+	  lp.col_lower_[i] = -1E5;
+	  lp.col_upper_[i] = 1E5;
+	}
+      }
+    }
+
+    highs.passModel(lp);
+    // Make free variables basic: false by default
+    assert(!settings.phase1movefreevarsbasic);
+    if (settings.phase1movefreevarsbasic) {
+      HighsBasis basis;
+      basis.alien = true;  // Set true when basis is instantiated
+      for (HighsInt i = 0; i < instance.num_con; i++) {
+	basis.row_status.push_back(HighsBasisStatus::kNonbasic);
+      }
+
+      for (HighsInt i = 0; i < instance.num_var; i++) {
+	// make free variables basic
+	if (instance.var_lo[i] == -kHighsInf &&
+	    instance.var_up[i] == kHighsInf) {
+	  // free variable
+	  basis.col_status.push_back(HighsBasisStatus::kBasic);
+	} else {
+	  basis.col_status.push_back(HighsBasisStatus::kNonbasic);
+	}
+      }
+
+      highs.setBasis(basis);
+
+      highs.setOptionValue("simplex_strategy", kSimplexStrategyPrimal);
+    }
+
+    HighsStatus status = highs.run();
+    if (status != HighsStatus::kOk) {
+      modelstatus = QpModelStatus::kError;
+      return;
+    }
+
+    stats.phase1_iterations = highs.getInfo().simplex_iteration_count;
+
+    HighsModelStatus phase1stat = highs.getModelStatus();
+    if (phase1stat == HighsModelStatus::kInfeasible) {
+      modelstatus = QpModelStatus::kInfeasible;
+      return;
+    }
+
+    use_basis = highs.getBasis();
+    use_solution = highs.getSolution();
+  }
+
+  HighsInt num_small_x0 = 0;
+  HighsInt num_small_ra = 0;
+  const double zero_activity_tolerance = have_starting_point ? 0 : 1e-4;
+  QpVector x0(instance.num_var);
+  QpVector ra(instance.num_con);
+  for (HighsInt i = 0; i < x0.dim; i++) {
+    if (fabs(use_solution.col_value[i]) > zero_activity_tolerance) {
+      x0.value[i] = use_solution.col_value[i];
+      x0.index[x0.num_nz++] = i;
+    } else if (fabs(use_solution.col_value[i]) > 0) {
+      num_small_x0++;
+    }
+  }
+
+  for (HighsInt i = 0; i < ra.dim; i++) {
+    if (fabs(use_solution.row_value[i]) > zero_activity_tolerance) {
+      ra.value[i] = use_solution.row_value[i];
+      ra.index[ra.num_nz++] = i;
+    } else if (fabs(use_solution.row_value[i]) > 0) {
+      num_small_ra++;
+    }
+  }
+  if (debug_report && num_small_x0+num_small_ra)
+    printf("feasibility_highs has %d small col values and %d small row values\n",
+	   int(num_small_x0), int(num_small_ra));
+  std::vector<HighsInt> initial_active;
+  std::vector<HighsInt> initial_inactive;
+  std::vector<BasisStatus> initial_status;
+
+  const HighsInt num_highs_basis_status = HighsInt(HighsBasisStatus::kNonbasic)+1;
+  std::vector<HighsInt> debug_row_status_count;
+  debug_row_status_count.assign(num_highs_basis_status, 0);
+  for (HighsInt i = 0; i < HighsInt(use_basis.row_status.size()); i++) {
+    HighsBasisStatus status = use_basis.row_status[i];
+    debug_row_status_count[HighsInt(status)]++;
+    if (status == HighsBasisStatus::kLower) {
+      initial_active.push_back(i);
+      initial_status.push_back(BasisStatus::kActiveAtLower);
+    } else if (status == HighsBasisStatus::kUpper) {
+      initial_active.push_back(i);
+      initial_status.push_back(BasisStatus::kActiveAtUpper);
+    } else if (status == HighsBasisStatus::kZero) {
+      // Shouldn't happen, since free rows are basic in a logical
+      // basis and remain basic, or are removed by presolve and
+      // restored as basic in postsolve
+      assert(111==222);
+      // That said, a free row that is nonbasic in the Highs basis
+      // must be counted as inactive in the QP basis for accounting
+      // purposes
+      initial_inactive.push_back(i);
+    } else if (status != HighsBasisStatus::kBasic) {
+      assert(status == HighsBasisStatus::kNonbasic);
+      // Surely an error, but not a problem before, since simplex
+      // solver cannot return a HighsBasisStatus::kNonbasic
+      // variable. Does matter now, since a saved QP basis will
+      // generally have such variables.
+      //
+      //      initial_inactive.push_back(instance.num_con + i);
+      //
+      // A HighsBasisStatus::kNonbasic variable corresponds one-to-one
+      // with being inactive in the QP basis
+      initial_inactive.push_back(i);
+    } else {
+      assert(status == HighsBasisStatus::kBasic);
+    }
+  }
+
+  std::vector<HighsInt> debug_col_status_count;
+  debug_col_status_count.assign(num_highs_basis_status, 0);
+  for (HighsInt i = 0; i < HighsInt(use_basis.col_status.size()); i++) {
+    HighsBasisStatus status = use_basis.col_status[i];
+    debug_col_status_count[HighsInt(status)]++;
+    if (status == HighsBasisStatus::kLower) {
+      if (isfreevar(instance, i)) {
+        initial_inactive.push_back(instance.num_con + i);
+      } else {
+        initial_active.push_back(instance.num_con + i);
+        initial_status.push_back(BasisStatus::kActiveAtLower);
+      }
+      
+    } else if (status == HighsBasisStatus::kUpper) {
+      if (isfreevar(instance, i)) {
+        initial_inactive.push_back(instance.num_con + i);
+      } else {
+        initial_active.push_back(instance.num_con + i);
+        initial_status.push_back(BasisStatus::kActiveAtUpper);
+      }
+      
+    } else if (status == HighsBasisStatus::kZero) {
+      initial_inactive.push_back(instance.num_con + i);
+    } else if (status != HighsBasisStatus::kBasic) {
+      assert(status == HighsBasisStatus::kNonbasic);
+      initial_inactive.push_back(instance.num_con + i);
+    } else {
+      assert(status == HighsBasisStatus::kBasic);
+    }
+  }
+
+  if (debug_report) {
+    printf("QP solver initial basis: (Lo / Bs / Up / Ze / Nb) for cols (");
+    for (HighsInt k = 0; k < num_highs_basis_status; k++) 
+      printf("%s%d", k==0 ? "" : " / ", int(debug_col_status_count[k]));
+    printf(") and rows (");
+    for (HighsInt k = 0; k < num_highs_basis_status; k++) 
+      printf("%s%d", k==0 ? "" : " / ", int(debug_row_status_count[k]));
+    printf(")\n");
+  }
+
+  assert((HighsInt)(initial_active.size() + initial_inactive.size()) ==
+	 instance.num_var);
+
+  if (!have_starting_point) {
+    // When starting from a feasible basis, there will generally be
+    // inactive variables in the basis that aren't free
+    for (HighsInt ia : initial_inactive) {
+      if (ia < instance.num_con) {
+	// printf("free row %d\n", (int)ia);
+	assert(instance.con_lo[ia] == -kHighsInf);
+	assert(instance.con_up[ia] == kHighsInf);
+      } else {
+	// printf("free col %d\n", (int)ia);
+	assert(instance.var_lo[ia - instance.num_con] == -kHighsInf);
+	assert(instance.var_up[ia - instance.num_con] == kHighsInf);
+      }
+    }
+  }
+
+  result.status = initial_status;
+  result.active = initial_active;
+  result.inactive = initial_inactive;
+  result.primal = x0;
+  result.rowact = ra;
+}
+
+#endif

casadi/include/highs/qpsolver/gradient.hpp

@@ -0,0 +1,39 @@
+#ifndef __SRC_LIB_GRADIENT_HPP__
+#define __SRC_LIB_GRADIENT_HPP__
+
+#include "runtime.hpp"
+#include "qpvector.hpp"
+
+class Gradient {
+  Runtime& runtime;
+
+  QpVector gradient;
+  bool uptodate;
+  HighsInt numupdates = 0;
+
+ public:
+  Gradient(Runtime& rt)
+      : runtime(rt), gradient(QpVector(rt.instance.num_var)), uptodate(false) {}
+
+  void recompute() {
+    runtime.instance.Q.vec_mat(runtime.primal, gradient);
+    gradient += runtime.instance.c;
+    uptodate = true;
+    numupdates = 0;
+  }
+
+  QpVector& getGradient() {
+    if (!uptodate ||
+        numupdates >= runtime.settings.gradientrecomputefrequency) {
+      recompute();
+    }
+    return gradient;
+  }
+
+  void update(QpVector& buffer_Qp, double stepsize) {
+    gradient.saxpy(stepsize, buffer_Qp);
+    numupdates++;
+  }
+};
+
+#endif

casadi/include/highs/qpsolver/instance.hpp

@@ -0,0 +1,63 @@
+#ifndef __SRC_LIB_INSTANCE_HPP__
+#define __SRC_LIB_INSTANCE_HPP__
+
+#include <vector>
+
+#include "matrix.hpp"
+#include "qpvector.hpp"
+
+struct SumNum {
+  double sum = 0.0;
+  HighsInt num = 0;
+};
+
+struct Instance {
+  HighsInt sense = 1; // Minimization
+  HighsInt num_var = 0;
+  HighsInt num_con = 0;
+  double offset = 0;
+  QpVector c;
+  Matrix Q;
+  std::vector<double> con_lo;
+  std::vector<double> con_up;
+  Matrix A;
+  std::vector<double> var_lo;
+  std::vector<double> var_up;
+
+  Instance(HighsInt nv = 0, HighsInt nc = 0)
+      : num_var(nv),
+        num_con(nc),
+        c(QpVector(nv)),
+        Q(Matrix(nv, nv)),
+        A(Matrix(nc, nv)) {}
+
+  double objval(const QpVector& x) {
+    return c * x + 0.5 * (Q.vec_mat(x) * x) + offset;
+  }
+
+  SumNum sumnumprimalinfeasibilities(const QpVector& x,
+                                     const QpVector& rowactivity) {
+    SumNum res;
+    for (HighsInt row = 0; row < num_con; row++) {
+      if (rowactivity.value[row] < con_lo[row]) {
+        res.sum += (con_lo[row] - rowactivity.value[row]);
+        res.num++;
+      } else if (rowactivity.value[row] > con_up[row]) {
+        res.sum += (rowactivity.value[row] - con_up[row]);
+        res.num++;
+      }
+    }
+    for (HighsInt var = 0; var < num_var; var++) {
+      if (x.value[var] < var_lo[var]) {
+        res.sum += (var_lo[var] - x.value[var]);
+        res.num++;
+      } else if (x.value[var] > var_up[var]) {
+        res.sum += (x.value[var] - var_up[var]);
+        res.num++;
+      }
+    }
+    return res;
+  }
+};
+
+#endif

casadi/include/highs/qpsolver/matrix.hpp

@@ -0,0 +1,335 @@
+#ifndef __SRC_LIB_MATRIX_HPP__
+#define __SRC_LIB_MATRIX_HPP__
+
+#include <cassert>
+#include <vector>
+
+#include "qpvector.hpp"
+
+struct MatrixBase {
+  HighsInt num_row;
+  HighsInt num_col;
+  std::vector<HighsInt> start;
+  std::vector<HighsInt> index;
+  std::vector<double> value;
+
+  QpVector& mat_vec(const QpVector& other, QpVector& target) const {
+    return mat_vec_seq(other, target);
+  }
+
+  QpVector& mat_vec_seq(const QpVector& other, QpVector& target) const {
+    target.reset();
+    for (HighsInt i = 0; i < other.num_nz; i++) {
+      HighsInt col = other.index[i];
+      for (HighsInt idx = start[col]; idx < start[col + 1]; idx++) {
+        HighsInt row = index[idx];
+        target.value[row] += value[idx] * other.value[col];
+      }
+    }
+    target.resparsify();
+    return target;
+  }
+
+  QpVector mat_vec(const QpVector& other) {
+    QpVector result(num_row);
+    mat_vec(other, result);
+    return result;
+  }
+
+  QpVector vec_mat(HighsInt* idx, double* val, HighsInt nnz) {
+    QpVector result(num_col);
+    for (HighsInt i = 0; i < num_col; i++) {
+      double dot = 0.0;
+      // HighsInt idx_other = 0;
+      // HighsInt idx_this = start[i];
+      // while (idx_this < start[i+1] && idx_other < nnz) {
+      //    if (idx[idx_other] == index[idx_this]) {
+      //       dot += val[idx_other] * value[idx_this];
+      //    } else if (idx[idx_other] < index[idx_this]) {
+      //       idx_other++;
+      //    } else {
+      //       idx_this++;
+      //    }
+      // }
+
+      for (HighsInt j = start[i]; j < start[i + 1]; j++) {
+        // does the vector have an entry for index index[j]?
+        double other_value = 0.0;
+        for (HighsInt k = 0; k < nnz; k++) {
+          if (idx[k] == index[j]) {
+            other_value = val[k];
+            break;
+          }
+        }
+
+        dot += other_value * value[j];
+      }
+
+      if (dot != 0.0) {
+        result.value[i] = dot;
+        result.index[result.num_nz] = i;
+        result.num_nz++;
+      }
+    }
+    return result;
+  }
+
+  QpVector& vec_mat(const QpVector& other, QpVector& target) const {
+    return vec_mat_1(other, target);
+  }
+
+  QpVector& vec_mat_1(const QpVector& other, QpVector& target) const {
+    target.reset();
+    for (HighsInt col = 0; col < num_col; col++) {
+      double dot = 0.0;
+      for (HighsInt j = start[col]; j < start[col + 1]; j++) {
+        dot += other.value[index[j]] * value[j];
+      }
+      target.value[col] = dot;
+    }
+
+    target.resparsify();
+    return target;
+  }
+
+  QpVector vec_mat(const QpVector& other) const {
+    QpVector result(num_col);
+
+    return vec_mat(other, result);
+  }
+
+  // computes this * mat, where "this" is a tranposed matrix
+  MatrixBase tran_mat_(const MatrixBase& other) {
+    MatrixBase res;
+    res.num_row = num_col;
+    res.num_col = other.num_col;
+
+    res.start.push_back(0);
+    QpVector buffer_col(other.num_row);
+    QpVector buffer_col_res(num_col);
+    for (HighsInt r = 0; r < other.num_col; r++) {
+      other.extractcol(r, buffer_col);
+
+      vec_mat(buffer_col, buffer_col_res);
+      for (HighsInt i = 0; i < buffer_col_res.num_nz; i++) {
+        res.index.push_back(buffer_col_res.index[i]);
+        res.value.push_back(buffer_col_res.value[buffer_col_res.index[i]]);
+      }
+      res.start.push_back(res.start[r] + buffer_col_res.num_nz);
+    }
+
+    return res;
+  }
+
+  QpVector& extractcol(HighsInt col, QpVector& target) const {
+    assert(target.dim == num_row);
+    target.reset();
+
+    if (col >= num_col) {
+      target.index[0] = col - num_col;
+      target.value[col - num_col] = 1.0;
+      target.num_nz = 1;
+    } else {
+      for (HighsInt i = 0; i < start[col + 1] - start[col]; i++) {
+        target.index[i] = index[start[col] + i];
+        target.value[target.index[i]] = value[start[col] + i];
+      }
+      target.num_nz = start[col + 1] - start[col];
+    }
+
+    return target;
+  }
+
+  QpVector extractcol(HighsInt col) const {
+    QpVector res(num_row);
+
+    return extractcol(col, res);
+  }
+};
+
+struct Matrix {
+ private:
+  MatrixBase tran;
+  bool has_transpose = false;
+
+  void transpose() {
+    if (!has_transpose) {
+      std::vector<std::vector<HighsInt>> row_indices(mat.num_row);
+      std::vector<std::vector<double>> row_values(mat.num_row);
+
+      for (HighsInt col = 0; col < mat.num_col; col++) {
+        for (HighsInt entry = mat.start[col]; entry < mat.start[col + 1];
+             entry++) {
+          HighsInt row = mat.index[entry];
+          double val = mat.value[entry];
+          row_indices[row].push_back(col);
+          row_values[row].push_back(val);
+        }
+      }
+      tran.start.clear();
+      tran.index.clear();
+      tran.value.clear();
+      tran.start.reserve(mat.num_row + 1);
+      tran.index.reserve(mat.index.size());
+      tran.value.reserve(mat.value.size());
+
+      tran.start.push_back(0);
+      for (HighsInt row = 0; row < mat.num_row; row++) {
+        tran.index.insert(tran.index.end(), row_indices[row].begin(),
+                          row_indices[row].end());
+        tran.value.insert(tran.value.end(), row_values[row].begin(),
+                          row_values[row].end());
+
+        tran.start.push_back(tran.start[row] + row_indices[row].size());
+      }
+
+      tran.num_col = mat.num_row;
+      tran.num_row = mat.num_col;
+    }
+  }
+
+ public:
+  MatrixBase mat;
+
+  Matrix(HighsInt nr, HighsInt nc) {
+    mat.num_row = nr;
+    mat.num_col = nc;
+  };
+
+  Matrix(const MatrixBase& m, bool needstran) {
+    mat = m;
+    // if (needstran) {
+    //    transpose();
+    // }
+  }
+
+  void append(const QpVector& vec) {
+    if (mat.num_col == 0 && mat.start.size() == 0) {
+      mat.start.push_back(0);
+    }
+    for (HighsInt i = 0; i < vec.num_nz; i++) {
+      mat.index.push_back(vec.index[i]);
+      mat.value.push_back(vec.value[vec.index[i]]);
+    }
+    mat.start.push_back(mat.start[mat.num_col] + vec.num_nz);
+    mat.num_col++;
+    has_transpose = false;
+  }
+
+  void append(HighsInt* idx, double* val, HighsInt nnz) {
+    if (mat.num_col == 0 && mat.start.size() == 0) {
+      mat.start.push_back(0);
+    }
+    for (HighsInt i = 0; i < nnz; i++) {
+      mat.index.push_back(idx[i]);
+      mat.value.push_back(val[i]);
+    }
+    mat.start.push_back(mat.start[mat.num_col] + nnz);
+    mat.num_col++;
+    has_transpose = false;
+  }
+
+  void append(HighsInt num_nz, HighsInt* index, double* value) {
+    if (mat.num_col == 0 && mat.start.size() == 0) {
+      mat.start.push_back(0);
+    }
+    for (HighsInt i = 0; i < num_nz; i++) {
+      mat.index.push_back(index[i]);
+      mat.value.push_back(value[i]);
+    }
+    mat.start.push_back(mat.start[mat.num_col] + num_nz);
+    mat.num_col++;
+    has_transpose = false;
+  }
+
+  void dropcol(HighsInt col) {
+    assert(col < mat.num_col);
+    has_transpose = false;
+
+    mat.index.erase(mat.index.begin() + mat.start[col],
+                    mat.index.begin() + mat.start[col + 1]);
+    mat.value.erase(mat.value.begin() + mat.start[col],
+                    mat.value.begin() + mat.start[col + 1]);
+
+    HighsInt num_elements_in_col = mat.start[col + 1] - mat.start[col];
+    for (; col < mat.num_col; col++) {
+      mat.start[col] = mat.start[col + 1] - num_elements_in_col;
+    }
+    mat.start.pop_back();
+    mat.num_col--;
+  }
+
+  MatrixBase& t() {
+    if (!has_transpose) {
+      transpose();
+      has_transpose = true;
+    }
+    return tran;
+  }
+
+  Matrix mat_mat(Matrix& other) {
+    Matrix res(mat.num_row, 0);
+
+    QpVector buffer(other.mat.num_row);
+    QpVector buffer2(mat.num_col);
+    for (HighsInt col = 0; col < other.mat.num_col; col++) {
+      res.append(vec_mat(other.mat.extractcol(col, buffer), buffer2));
+    }
+
+    return res;
+  }
+
+  Matrix tran_mat(Matrix& other) {
+    Matrix res(mat.num_col, 0);
+
+    QpVector buffer(other.mat.num_row);
+    QpVector buffer2(mat.num_row);
+    for (HighsInt col = 0; col < other.mat.num_col; col++) {
+      res.append(mat_vec(other.mat.extractcol(col, buffer), buffer2));
+    }
+    return res;
+  }
+
+  QpVector& mat_vec(const QpVector& other, QpVector& target) {
+    return mat.mat_vec(other, target);
+  }
+
+  QpVector mat_vec(const QpVector& other) { return mat.mat_vec(other); }
+
+  QpVector vec_mat(const QpVector& other) const { return mat.vec_mat(other); }
+
+  QpVector& vec_mat(const QpVector& other, QpVector& target) const {
+    return mat.vec_mat(other, target);
+  }
+
+  QpVector vec_mat(HighsInt* index, double* value, HighsInt num_nz) {
+    return mat.vec_mat(index, value, num_nz);
+  }
+
+  void report(std::string name = "") const {
+    if (name != "") {
+      printf("%s:", name.c_str());
+    }
+    printf("[%" HIGHSINT_FORMAT " x %" HIGHSINT_FORMAT "]\n", mat.num_row,
+           mat.num_col);
+    printf("start: ");
+    for (HighsInt i : mat.start) {
+      printf("%" HIGHSINT_FORMAT " ", i);
+    }
+    printf("\n");
+
+    printf("index: ");
+    for (HighsInt i : mat.index) {
+      printf("%" HIGHSINT_FORMAT " ", i);
+    }
+    printf("\n");
+
+    printf("value: ");
+    for (double d : mat.value) {
+      printf("%lf ", d);
+    }
+    printf("\n");
+  }
+};
+
+#endif