lpsolver 0.1.0 → 0.2.1

data/ext/lpsolver-highs/highs/simplex/HSimplexNlaDebug.cpp

@@ -0,0 +1,373 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file simplex/HSimplexNlaDebug.cpp
+ *
+ * @brief Debugging code for simplex NLA
+ */
+#include "simplex/HSimplexNla.h"
+#include "util/HighsRandom.h"
+
+// #include <stdio.h>
+
+const double kResidualLargeError = 1e-8;
+const double kResidualExcessiveError = sqrt(kResidualLargeError);
+
+const double kSolveLargeError = 1e-8;
+const double kSolveExcessiveError = sqrt(kSolveLargeError);
+
+HighsDebugStatus HSimplexNla::debugCheckInvert(
+    const std::string message, const HighsInt alt_debug_level) const {
+  // Sometimes a value other than highs_debug_level is passed as
+  // alt_debug_level, either to force debugging, or to limit
+  // debugging. If no value is passed, then alt_debug_level = -1, and
+  // highs_debug_level is used
+  const HighsInt use_debug_level = alt_debug_level >= 0
+                                       ? alt_debug_level
+                                       : this->options_->highs_debug_level;
+  if (use_debug_level < kHighsDebugLevelCostly)
+    return HighsDebugStatus::kNotChecked;
+  // If highs_debug_level isn't being used, then indicate that it's
+  // being forced, and also force reporting of OK errors
+  const bool force = alt_debug_level > this->options_->highs_debug_level;
+  if (force)
+    highsLogDev(this->options_->log_options, HighsLogType::kInfo,
+                "CheckNlaINVERT:   Forcing debug\n");
+
+  HighsDebugStatus return_status = HighsDebugStatus::kNotChecked;
+  return_status = HighsDebugStatus::kOk;
+
+  const HighsInt num_row = this->lp_->num_row_;
+  const HighsInt num_col = this->lp_->num_col_;
+  const vector<HighsInt>& a_matrix_start = this->lp_->a_matrix_.start_;
+  const vector<HighsInt>& a_matrix_index = this->lp_->a_matrix_.index_;
+  const vector<double>& a_matrix_value = this->lp_->a_matrix_.value_;
+  const HighsInt* basic_index = this->basic_index_;
+  const HighsOptions* options = this->options_;
+  // Make sure that this isn't called between the matrix and LP resizing
+  assert(num_row == this->lp_->a_matrix_.num_row_);
+  assert(num_col == this->lp_->a_matrix_.num_col_);
+  const bool report = (options->log_dev_level != 0);
+
+  highsLogDev(options->log_options, HighsLogType::kInfo, "\nCheckINVERT: %s\n",
+              message.c_str());
+
+  HVector column;
+  HVector rhs;
+  column.setup(num_row);
+  rhs.setup(num_row);
+  HVector residual;
+  double expected_density = 1;
+
+  const bool random_ftran_test = true;
+  const bool report_basis = options->log_dev_level > 1 && num_row < 20;
+  if (random_ftran_test) {
+    // Solve for a random solution
+    HighsRandom random(1);
+    // Solve Bx=b
+    column.clear();
+    rhs.clear();
+    column.count = -1;
+    if (report_basis)
+      highsLogDev(options_->log_options, HighsLogType::kInfo, "Basis:");
+    for (HighsInt iRow = 0; iRow < num_row; iRow++) {
+      rhs.index[rhs.count++] = iRow;
+      double value = random.fraction();
+      column.array[iRow] = value;
+      HighsInt iCol = basic_index[iRow];
+      if (report_basis)
+        highsLogDev(options_->log_options, HighsLogType::kInfo, " %1d",
+                    (int)iCol);
+      if (iCol < num_col) {
+        for (HighsInt iEl = a_matrix_start[iCol];
+             iEl < a_matrix_start[iCol + 1]; iEl++) {
+          HighsInt index = a_matrix_index[iEl];
+          rhs.array[index] += value * a_matrix_value[iEl];
+        }
+      } else {
+        HighsInt index = iCol - num_col;
+        assert(index < num_row);
+        rhs.array[index] += value;
+      }
+    }
+    if (report_basis)
+      highsLogDev(options_->log_options, HighsLogType::kInfo, "\n");
+    residual = rhs;
+    //  if (options->log_dev_level) {
+    //    reportArray("Random solution before FTRAN", &column, true);
+    //    reportArray("Random RHS      before FTRAN", &rhs, true);
+    //  }
+    this->ftran(rhs, expected_density);
+
+    return_status =
+        debugReportInvertSolutionError(false, column, rhs, residual, force);
+  }
+
+  const bool random_btran_test = true;
+  if (random_btran_test) {
+    // Solve B^Tx=b
+    rhs.clear();
+    for (HighsInt iRow = 0; iRow < num_row; iRow++) {
+      rhs.index[rhs.count++] = iRow;
+      HighsInt iCol = basic_index[iRow];
+      if (iCol < num_col) {
+        for (HighsInt iEl = a_matrix_start[iCol];
+             iEl < a_matrix_start[iCol + 1]; iEl++) {
+          rhs.array[iRow] +=
+              column.array[a_matrix_index[iEl]] * a_matrix_value[iEl];
+        }
+      } else {
+        rhs.array[iRow] += column.array[iCol - num_col];
+      }
+    }
+    residual = rhs;
+    this->btran(rhs, expected_density);
+
+    return_status =
+        debugReportInvertSolutionError(true, column, rhs, residual, force);
+  }
+
+  if (use_debug_level < kHighsDebugLevelExpensive) return return_status;
+
+  std::string value_adjective;
+  expected_density = 0;
+  double inverse_error_norm = 0;
+  double residual_error_norm = 0;
+  const bool test_inverse_ftran = true;
+  if (test_inverse_ftran) {
+    // Solve BX=B
+    HighsInt check_col = -1;
+    for (HighsInt iRow = 0; iRow < num_row; iRow++) {
+      HighsInt iCol = basic_index[iRow];
+      column.clear();
+      column.packFlag = true;
+      if (iCol < num_col) {
+        for (HighsInt k = a_matrix_start[iCol]; k < a_matrix_start[iCol + 1];
+             k++) {
+          HighsInt index = a_matrix_index[k];
+          column.array[index] = a_matrix_value[k];
+          column.index[column.count++] = index;
+        }
+      } else {
+        HighsInt index = iCol - num_col;
+        column.array[index] = 1.0;
+        column.index[column.count++] = index;
+      }
+      const bool report_col = report && iRow == check_col;
+      if (report_col) {
+        reportArray("Check col before FTRAN", &column, true);
+        //      factor_.reportLu(kReportLuBoth, true);
+      }
+      HVector residual = column;
+      this->ftran(column, expected_density);
+      if (report_col) reportArray("Check col after  FTRAN", &column, true);
+      double inverse_col_error_norm = 0;
+      for (HighsInt lc_iRow = 0; lc_iRow < num_row; lc_iRow++) {
+        double ckValue = lc_iRow == iRow ? 1 : 0;
+        double inverse_error = fabs(column.array[lc_iRow] - ckValue);
+        inverse_col_error_norm =
+            std::max(inverse_error, inverse_col_error_norm);
+      }
+      // Extra printing of intermediate errors
+      if (report_col)
+        highsLogDev(
+            options->log_options, HighsLogType::kInfo,
+            "CheckINVERT: Basic column %2d = %2d has inverse error %11.4g\n",
+            (int)iRow, int(iCol), inverse_col_error_norm);
+      inverse_error_norm = std::max(inverse_col_error_norm, inverse_error_norm);
+      double residual_col_error_norm =
+          debugInvertResidualError(false, column, residual);
+      residual_error_norm =
+          std::max(residual_col_error_norm, residual_error_norm);
+    }
+    return_status = debugReportInvertSolutionError(
+        "inverse", false, inverse_error_norm, residual_error_norm, force);
+  }
+
+  const bool test_inverse_btran = true;
+  if (test_inverse_btran) {
+    // Solve B^TX=B^T
+    HighsInt check_row = -2;
+    inverse_error_norm = 0;
+    residual_error_norm = 0;
+    for (HighsInt iRow = 0; iRow < num_row; iRow++) {
+      column.clear();
+      column.packFlag = true;
+      for (HighsInt iCol = 0; iCol < num_row; iCol++) {
+        HighsInt iVar = basic_index[iCol];
+        if (iVar < num_col) {
+          for (HighsInt k = a_matrix_start[iVar]; k < a_matrix_start[iVar + 1];
+               k++) {
+            if (a_matrix_index[k] == iRow) {
+              column.array[iCol] = a_matrix_value[k];
+              break;
+            }
+          }
+        } else {
+          if (iVar == num_col + iRow) column.array[iCol] = 1.0;
+        }
+      }
+      for (HighsInt iCol = 0; iCol < num_row; iCol++) {
+        if (column.array[iCol]) column.index[column.count++] = iCol;
+      }
+      const bool report_row = report && iRow == check_row;
+      if (report_row) {
+        reportArray("Check col before BTRAN", &column, true);
+        //      factor_.reportLu(kReportLuBoth, true);
+      }
+      HVector residual = column;
+      this->btran(column, expected_density);
+      if (report_row) reportArray("Check col after  BTRAN", &column, true);
+      double inverse_col_error_norm = 0;
+      for (HighsInt lc_iRow = 0; lc_iRow < num_row; lc_iRow++) {
+        double value = column.array[lc_iRow];
+        double ckValue = lc_iRow == iRow ? 1 : 0;
+        double inverse_error = fabs(value - ckValue);
+        inverse_col_error_norm =
+            std::max(inverse_error, inverse_col_error_norm);
+      }
+      // Extra printing of intermediate errors
+      if (report_row)
+        highsLogDev(
+            options->log_options, HighsLogType::kInfo,
+            "CheckINVERT: Basis matrix row %2d has inverse error %11.4g\n",
+            (int)iRow, inverse_col_error_norm);
+      inverse_error_norm = std::max(inverse_col_error_norm, inverse_error_norm);
+      double residual_col_error_norm =
+          debugInvertResidualError(true, column, residual);
+      residual_error_norm =
+          std::max(residual_col_error_norm, residual_error_norm);
+    }
+    return_status = debugReportInvertSolutionError(
+        "inverse", true, inverse_error_norm, residual_error_norm, force);
+  }
+
+  return return_status;
+}
+
+double HSimplexNla::debugInvertResidualError(const bool transposed,
+                                             const HVector& solution,
+                                             HVector& residual) const {
+  const HighsInt num_row = this->lp_->num_row_;
+  const HighsInt num_col = this->lp_->num_col_;
+  const vector<HighsInt>& a_matrix_start = this->lp_->a_matrix_.start_;
+  const vector<HighsInt>& a_matrix_index = this->lp_->a_matrix_.index_;
+  const vector<double>& a_matrix_value = this->lp_->a_matrix_.value_;
+  const HighsInt* basic_index = this->basic_index_;
+
+  if (transposed) {
+    for (HighsInt iRow = 0; iRow < num_row; iRow++) {
+      HighsInt iCol = basic_index[iRow];
+      if (iCol < num_col) {
+        for (HighsInt iEl = a_matrix_start[iCol];
+             iEl < a_matrix_start[iCol + 1]; iEl++) {
+          HighsInt index = a_matrix_index[iEl];
+          double value = solution.array[index];
+          residual.array[iRow] -= value * a_matrix_value[iEl];
+        }
+      } else {
+        HighsInt index = iCol - num_col;
+        double value = solution.array[index];
+        residual.array[iRow] -= value;
+      }
+    }
+  } else {
+    for (HighsInt iRow = 0; iRow < num_row; iRow++) {
+      double value = solution.array[iRow];
+      HighsInt iCol = basic_index[iRow];
+      if (iCol < num_col) {
+        for (HighsInt iEl = a_matrix_start[iCol];
+             iEl < a_matrix_start[iCol + 1]; iEl++) {
+          HighsInt index = a_matrix_index[iEl];
+          residual.array[index] -= value * a_matrix_value[iEl];
+        }
+      } else {
+        HighsInt index = iCol - num_col;
+        residual.array[index] -= value;
+      }
+    }
+  }
+
+  double residual_error_norm = 0;
+  for (HighsInt iRow = 0; iRow < num_row; iRow++) {
+    double residual_error = fabs(residual.array[iRow]);
+    residual_error_norm = std::max(residual_error, residual_error_norm);
+  }
+  return residual_error_norm;
+}
+
+HighsDebugStatus HSimplexNla::debugReportInvertSolutionError(
+    const bool transposed, const HVector& true_solution,
+    const HVector& solution, HVector& residual, const bool force) const {
+  const HighsInt num_row = this->lp_->num_row_;
+  double solve_error_norm = 0;
+  for (HighsInt iRow = 0; iRow < num_row; iRow++) {
+    double solve_error = fabs(solution.array[iRow] - true_solution.array[iRow]);
+    solve_error_norm = std::max(solve_error, solve_error_norm);
+  }
+  double residual_error_norm =
+      debugInvertResidualError(transposed, solution, residual);
+
+  return debugReportInvertSolutionError("random solution", transposed,
+                                        solve_error_norm, residual_error_norm,
+                                        force);
+}
+
+HighsDebugStatus HSimplexNla::debugReportInvertSolutionError(
+    const std::string source, const bool transposed,
+    const double solve_error_norm, const double residual_error_norm,
+    const bool force) const {
+  const HighsOptions* options = this->options_;
+  std::string value_adjective;
+  HighsLogType report_level;
+  HighsDebugStatus return_status = HighsDebugStatus::kOk;
+  std::string type = "";
+  if (transposed) type = "transposed ";
+  if (solve_error_norm) {
+    if (solve_error_norm > kSolveExcessiveError) {
+      value_adjective = "Excessive";
+      report_level = HighsLogType::kError;
+    } else if (solve_error_norm > kSolveLargeError) {
+      value_adjective = "Large";
+      report_level = HighsLogType::kWarning;
+    } else {
+      value_adjective = "Small";
+      report_level = HighsLogType::kInfo;
+    }
+    if (force) report_level = HighsLogType::kInfo;
+    //    printf("%s\n", value_adjective.c_str());
+    //    printf("%g\n", solve_error_norm);
+    //    printf("%s\n", type.c_str());
+    //    printf("%s\n", source.c_str());
+    highsLogDev(options->log_options, report_level,
+                "CheckINVERT:   %-9s (%9.4g) norm for %s%s solve error\n",
+                value_adjective.c_str(), solve_error_norm, type.c_str(),
+                source.c_str());
+  }
+
+  if (residual_error_norm) {
+    if (residual_error_norm > kResidualExcessiveError) {
+      value_adjective = "Excessive";
+      report_level = HighsLogType::kError;
+      return_status = HighsDebugStatus::kError;
+    } else if (residual_error_norm > kResidualLargeError) {
+      value_adjective = "Large";
+      report_level = HighsLogType::kWarning;
+      return_status = HighsDebugStatus::kWarning;
+    } else {
+      value_adjective = "Small";
+      report_level = HighsLogType::kInfo;
+    }
+    if (force) report_level = HighsLogType::kInfo;
+    highsLogDev(options->log_options, report_level,
+                "CheckINVERT:   %-9s (%9.4g) norm for %s%s "
+                "residual error\n",
+                value_adjective.c_str(), residual_error_norm, type.c_str(),
+                source.c_str());
+  }
+  return return_status;
+}

data/ext/lpsolver-highs/highs/simplex/HSimplexNlaFreeze.cpp

@@ -0,0 +1,28 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file simplex/HSimplexNlaFreeze.cpp
+ *
+ * @brief Interface to HFactor allowing non-HFactor updates, NLA-only
+ * scaling and shifting of NLA analysis below simplex level.
+ */
+#include <stdio.h>
+
+#include "simplex/HSimplexNla.h"
+
+void SimplexIterate::clear() {
+  this->valid_ = false;
+  this->basis_.clear();
+  this->invert_.clear();
+  this->dual_edge_weight_.clear();
+}
+
+void HSimplexNla::putInvert() {
+  simplex_iterate_.valid_ = true;
+  simplex_iterate_.invert_ = factor_.getInvert();
+}
+void HSimplexNla::getInvert() { factor_.setInvert(simplex_iterate_.invert_); }

data/ext/lpsolver-highs/highs/simplex/HSimplexNlaProductForm.cpp

@@ -0,0 +1,113 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file simplex/HSimplexNlaProductForm.cpp
+ *
+ * @brief Product form update methods for simplex NLA
+ */
+#include "simplex/HSimplexNla.h"
+
+// #include <stdio.h>
+#include <algorithm>
+
+using std::fabs;
+const HighsInt kProductFormExtraEntries = 1000;
+const HighsInt kProductFormMaxUpdates = 50;
+const double kProductFormPivotTolerance = 1e-8;
+
+void ProductFormUpdate::clear() {
+  valid_ = false;
+  num_row_ = 0;
+  update_count_ = 0;
+  pivot_index_.clear();
+  pivot_value_.clear();
+  start_.clear();
+  index_.clear();
+  value_.clear();
+}
+
+void ProductFormUpdate::setup(const HighsInt num_row,
+                              const double expected_density) {
+  valid_ = true;
+  num_row_ = num_row;
+  update_count_ = 0;
+  start_.push_back(0);
+  HighsInt reserve_entry_space =
+      kProductFormExtraEntries +
+      kProductFormMaxUpdates * num_row * expected_density;
+  index_.reserve(reserve_entry_space);
+  value_.reserve(reserve_entry_space);
+}
+
+HighsInt ProductFormUpdate::update(HVector* aq, HighsInt* pivot_row) {
+  assert(0 <= *pivot_row && *pivot_row < num_row_);
+  if (update_count_ >= kProductFormMaxUpdates)
+    return kRebuildReasonUpdateLimitReached;
+  double pivot = aq->array[*pivot_row];
+  if (fabs(pivot) < kProductFormPivotTolerance)
+    return kRebuildReasonPossiblySingularBasis;
+  pivot_index_.push_back(*pivot_row);
+  pivot_value_.push_back(pivot);
+  for (HighsInt iX = 0; iX < aq->count; iX++) {
+    HighsInt iRow = aq->index[iX];
+    if (iRow == *pivot_row) continue;
+    index_.push_back(iRow);
+    value_.push_back(aq->array[iRow]);
+  }
+  start_.push_back(index_.size());
+  update_count_++;
+  return kRebuildReasonNo;
+}
+
+void ProductFormUpdate::btran(HVector& rhs) const {
+  if (!valid_) return;
+  assert(rhs.size == num_row_);
+  assert((int)start_.size() == update_count_ + 1);
+  for (HighsInt iX = update_count_ - 1; iX >= 0; iX--) {
+    const HighsInt pivot_index = pivot_index_[iX];
+    double pivot_value = rhs.array[pivot_index];
+    for (HighsInt iEl = start_[iX]; iEl < start_[iX + 1]; iEl++)
+      pivot_value -= value_[iEl] * rhs.array[index_[iEl]];
+    pivot_value /= pivot_value_[iX];
+    if (rhs.array[pivot_index] == 0) rhs.index[rhs.count++] = pivot_index;
+    rhs.array[pivot_index] =
+        (fabs(pivot_value) < kHighsTiny) ? 1e-100 : pivot_value;
+  }
+}
+
+void ProductFormUpdate::ftran(HVector& rhs) const {
+  if (!valid_) return;
+  assert(rhs.size == num_row_);
+  assert((int)start_.size() == update_count_ + 1);
+  // Use the zeroed rhs.cwork to record whether a row is in the index
+  // list. If RHS fill-in occurs in a row, then we have to add it to
+  // the list. We're not tracking cancellation, so we don't need to
+  // know where a row appears in the list
+  vector<char>& in_index = rhs.cwork;
+  for (HighsInt iX = 0; iX < rhs.count; iX++) in_index[rhs.index[iX]] = 1;
+
+  for (HighsInt iX = 0; iX < update_count_; iX++) {
+    const HighsInt pivot_index = pivot_index_[iX];
+    double pivot_value = rhs.array[pivot_index];
+    if (fabs(pivot_value) > kHighsTiny) {
+      assert(in_index[pivot_index]);
+      pivot_value /= pivot_value_[iX];
+      rhs.array[pivot_index] = pivot_value;
+      for (HighsInt iEl = start_[iX]; iEl < start_[iX + 1]; iEl++) {
+        HighsInt iRow = index_[iEl];
+        rhs.array[iRow] -= pivot_value * value_[iEl];
+        if (in_index[iRow]) continue;
+        in_index[iRow] = 1;
+        rhs.index[rhs.count++] = iRow;
+      }
+    } else {
+      rhs.array[pivot_index] = 0;
+    }
+  }
+  // Zero the in_index entries used to point into the index list
+  for (HighsInt iX = 0; iX < rhs.count; iX++) in_index[rhs.index[iX]] = 0;
+}

data/ext/lpsolver-highs/highs/simplex/HSimplexReport.cpp

@@ -0,0 +1,77 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file lp_data/HSimplexDebug.cpp
+ * @brief
+ */
+
+#include "simplex/HSimplexReport.h"
+
+#include <sstream>
+
+void reportSimplexPhaseIterations(const HighsLogOptions& log_options,
+                                  const HighsInt iteration_count,
+                                  HighsSimplexInfo& info,
+                                  const bool initialise) {
+  if (info.run_quiet) return;
+  if (initialise) {
+    info.iteration_count0 = iteration_count;
+    info.dual_phase1_iteration_count0 = info.dual_phase1_iteration_count;
+    info.dual_phase2_iteration_count0 = info.dual_phase2_iteration_count;
+    info.primal_phase1_iteration_count0 = info.primal_phase1_iteration_count;
+    info.primal_phase2_iteration_count0 = info.primal_phase2_iteration_count;
+    info.primal_bound_swap0 = info.primal_bound_swap;
+    return;
+  }
+  const HighsInt delta_iteration_count =
+      iteration_count - info.iteration_count0;
+  const HighsInt delta_dual_phase1_iteration_count =
+      info.dual_phase1_iteration_count - info.dual_phase1_iteration_count0;
+  const HighsInt delta_dual_phase2_iteration_count =
+      info.dual_phase2_iteration_count - info.dual_phase2_iteration_count0;
+  const HighsInt delta_primal_phase1_iteration_count =
+      info.primal_phase1_iteration_count - info.primal_phase1_iteration_count0;
+  const HighsInt delta_primal_phase2_iteration_count =
+      info.primal_phase2_iteration_count - info.primal_phase2_iteration_count0;
+  const HighsInt delta_primal_bound_swap =
+      info.primal_bound_swap - info.primal_bound_swap0;
+
+  HighsInt check_delta_iteration_count =
+      delta_dual_phase1_iteration_count + delta_dual_phase2_iteration_count +
+      delta_primal_phase1_iteration_count + delta_primal_phase2_iteration_count;
+  if (check_delta_iteration_count != delta_iteration_count) {
+    highsLogUser(
+        log_options, HighsLogType::kError,
+        "Iteration total error %" HIGHSINT_FORMAT " + %" HIGHSINT_FORMAT
+        " + %" HIGHSINT_FORMAT " + %" HIGHSINT_FORMAT " = %" HIGHSINT_FORMAT
+        " != %" HIGHSINT_FORMAT "\n",
+        delta_dual_phase1_iteration_count, delta_dual_phase2_iteration_count,
+        delta_primal_phase1_iteration_count,
+        delta_primal_phase2_iteration_count, check_delta_iteration_count,
+        delta_iteration_count);
+  }
+  std::stringstream iteration_report;
+  if (delta_dual_phase1_iteration_count) {
+    iteration_report << "DuPh1 " << delta_dual_phase1_iteration_count << "; ";
+  }
+  if (delta_dual_phase2_iteration_count) {
+    iteration_report << "DuPh2 " << delta_dual_phase2_iteration_count << "; ";
+  }
+  if (delta_primal_phase1_iteration_count) {
+    iteration_report << "PrPh1 " << delta_primal_phase1_iteration_count << "; ";
+  }
+  if (delta_primal_phase2_iteration_count) {
+    iteration_report << "PrPh2 " << delta_primal_phase2_iteration_count << "; ";
+  }
+  if (delta_primal_bound_swap) {
+    iteration_report << "PrSwap " << delta_primal_bound_swap << "; ";
+  }
+
+  highsLogDev(log_options, HighsLogType::kInfo,
+              "Simplex iterations: %sTotal %" HIGHSINT_FORMAT "\n",
+              iteration_report.str().c_str(), delta_iteration_count);
+}

data/ext/lpsolver-highs/highs/simplex/HSimplexReport.h

@@ -0,0 +1,21 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file lp_data/HSimplexReport.h
+ * @brief
+ */
+#ifndef SIMPLEX_HSIMPLEXREPORT_H_
+#define SIMPLEX_HSIMPLEXREPORT_H_
+
+#include "lp_data/HighsOptions.h"
+#include "simplex/HSimplex.h"
+
+void reportSimplexPhaseIterations(const HighsLogOptions& log_options,
+                                  const HighsInt iteration_count,
+                                  HighsSimplexInfo& info,
+                                  const bool initialise = false);
+#endif  // SIMPLEX_HSIMPLEXREPORT_H_