lpsolver 0.1.0 → 0.2.0

data/ext/lpsolver-highs/highs/util/HFactorRefactor.cpp

@@ -0,0 +1,304 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file util/HFactorRefactor.cpp
+ * @brief Types of solution classes
+ */
+#include <cassert>
+#include <cmath>
+#include <iostream>
+
+#include "util/HFactor.h"
+#include "util/HVectorBase.h"
+
+// std::max and std::min used in HFactor.h for local in-line
+// functions, so HFactor.h has #include <algorithm>
+using std::fabs;
+
+void RefactorInfo::clear() {
+  this->use = false;
+  this->build_synthetic_tick = 0.0;
+  this->pivot_var.clear();
+  this->pivot_row.clear();
+  this->pivot_type.clear();
+}
+
+HighsInt HFactor::rebuild(HighsTimerClock* factor_timer_clock_pointer) {
+  const bool report_lu = false;
+  // Check that the refactorization information should be used
+  assert(refactor_info_.use);
+  /**
+   * 0. Clear L and U factor
+   */
+  luClear();
+
+  nwork = 0;
+  basis_matrix_num_el = 0;
+  HighsInt stage = num_row;
+  HighsInt rank_deficiency = 0;
+  vector<bool> has_pivot;
+  has_pivot.assign(num_row, false);
+  const bool report_unit = false;
+  const bool report_singletons = false;
+  const bool report_markowitz = false;
+  const bool report_anything =
+      report_unit || report_singletons || report_markowitz;
+  if (report_anything) printf("\nRefactor\n");
+  // Take build_synthetic_tick from the refactor info so that this
+  // refactorization doesn't look unrealistically cheap.
+  this->build_synthetic_tick = this->refactor_info_.build_synthetic_tick;
+  // Check that the refactorization info has been set up
+  assert((int)this->refactor_info_.pivot_row.size() >= num_row);
+  assert((int)this->refactor_info_.pivot_var.size() >= num_row);
+  assert((int)this->refactor_info_.pivot_type.size() >= num_row);
+  for (HighsInt iK = 0; iK < num_row; iK++) {
+    HighsInt iRow = this->refactor_info_.pivot_row[iK];
+    HighsInt iVar = this->refactor_info_.pivot_var[iK];
+    int8_t pivot_type = this->refactor_info_.pivot_type[iK];
+    assert(!has_pivot[iRow]);
+
+    if (pivot_type == kPivotLogical || pivot_type == kPivotUnit) {
+      if (pivot_type == kPivotLogical) {
+        //
+        // 1.1 Logical column
+        if (report_unit) printf("Stage %d: Logical\n", (int)iK);
+        assert(iVar >= num_col);
+        basis_matrix_num_el++;
+      } else if (pivot_type == kPivotUnit) {
+        //
+        // 1.2 (Structural) unit column
+        if (report_unit) printf("Stage %d: Unit\n", (int)iK);
+        assert(iVar < num_col);
+        HighsInt start = a_start[iVar];
+        HighsInt count = a_start[iVar + 1] - start;
+        assert(a_index[start] == iRow);
+        assert(count == 1 && a_value[start] == 1);
+        basis_matrix_num_el++;
+      }
+      // 1.3 Record unit column
+      l_start.push_back(l_index.size());
+      u_pivot_index.push_back(iRow);
+      u_pivot_value.push_back(1);
+      u_start.push_back(u_index.size());
+    } else if (pivot_type == kPivotRowSingleton ||
+               pivot_type == kPivotColSingleton) {
+      //
+      // Row or column singleton
+      assert(iVar < num_col);
+      const HighsInt start = a_start[iVar];
+      const HighsInt end = a_start[iVar + 1];
+      // Find where the pivot is
+      HighsInt pivot_k = -1;
+      for (HighsInt k = start; k < end; k++) {
+        if (a_index[k] == iRow) {
+          pivot_k = k;
+          break;
+        }
+      }
+      assert(pivot_k >= 0);
+      // Check that the pivot isn't too small. Shouldn't happen since
+      // this is refactorization
+      double abs_pivot = std::fabs(a_value[pivot_k]);
+      assert(abs_pivot >= pivot_tolerance);
+      if (abs_pivot < pivot_tolerance) {
+        rank_deficiency = nwork + 1;
+        return rank_deficiency;
+      }
+      if (pivot_type == kPivotRowSingleton) {
+        //
+        // 2.2 Deal with row singleton
+        const double pivot_multiplier = 1 / a_value[pivot_k];
+        if (report_singletons)
+          printf("Stage %d: Row singleton (%4d, %g)\n", (int)iK, (int)pivot_k,
+                 pivot_multiplier);
+        for (HighsInt section = 0; section < 2; section++) {
+          HighsInt p0 = section == 0 ? start : pivot_k + 1;
+          HighsInt p1 = section == 0 ? pivot_k : end;
+          for (HighsInt k = p0; k < p1; k++) {
+            HighsInt local_iRow = a_index[k];
+            if (!has_pivot[local_iRow]) {
+              if (report_singletons)
+                printf("Row singleton: L En (%4d, %11.4g)\n", (int)local_iRow,
+                       a_value[k] * pivot_multiplier);
+              l_index.push_back(local_iRow);
+              l_value.push_back(a_value[k] * pivot_multiplier);
+            } else {
+              if (report_singletons)
+                printf("Row singleton: U En (%4d, %11.4g)\n", (int)local_iRow,
+                       a_value[k]);
+              u_index.push_back(local_iRow);
+              u_value.push_back(a_value[k]);
+            }
+          }
+        }
+        l_start.push_back(l_index.size());
+        if (report_singletons)
+          printf("Row singleton: U Pv (%4d, %11.4g)\n", (int)iRow,
+                 a_value[pivot_k]);
+        u_pivot_index.push_back(iRow);
+        u_pivot_value.push_back(a_value[pivot_k]);
+        u_start.push_back(u_index.size());
+      } else {
+        //
+        // 2.3 Deal with column singleton
+        if (report_singletons) printf("Stage %d: Col singleton\n", (int)iK);
+        for (HighsInt k = start; k < pivot_k; k++) {
+          if (report_singletons)
+            printf("Col singleton: U En (%4d, %11.4g)\n", (int)a_index[k],
+                   a_value[k]);
+          u_index.push_back(a_index[k]);
+          u_value.push_back(a_value[k]);
+        }
+        for (HighsInt k = pivot_k + 1; k < end; k++) {
+          if (report_singletons)
+            printf("Col singleton: U En (%4d, %11.4g)\n", (int)a_index[k],
+                   a_value[k]);
+          u_index.push_back(a_index[k]);
+          u_value.push_back(a_value[k]);
+        }
+        l_start.push_back(l_index.size());
+        if (report_singletons)
+          printf("Col singleton: U Pv (%4d, %11.4g)\n", (int)iRow,
+                 a_value[pivot_k]);
+        u_pivot_index.push_back(iRow);
+        u_pivot_value.push_back(a_value[pivot_k]);
+        u_start.push_back(u_index.size());
+      }
+    } else {
+      assert(pivot_type == kPivotMarkowitz);
+      stage = iK;
+      break;
+    }
+    basic_index[iRow] = iVar;
+    has_pivot[iRow] = true;
+  }
+  if (report_lu) {
+    printf("\nAfter units and singletons\n");
+    reportLu(kReportLuBoth, false);
+  }
+  if (stage < num_row) {
+    // Handle the remaining Markowitz pivots
+    //
+    // First of all complete the L factor with identity columns so
+    // that FtranL counts the RHS entries in rows that don't yet have
+    // pivots by running to completion. In the hyper-sparse code,
+    // these will HOPEFULLY be skipped
+    //
+    // There are already l_start entries for the first stage rows, but
+    // l_pivot_index is not assigned, as u_pivot_index gets copied into it
+    l_start.resize(num_row + 1);
+    for (HighsInt iK = stage; iK < num_row; iK++) l_start[iK + 1] = l_start[iK];
+    l_pivot_index.resize(num_row);
+    for (HighsInt iK = 0; iK < num_row; iK++)
+      l_pivot_index[iK] = this->refactor_info_.pivot_row[iK];
+    // To do hyper-sparse FtranL operations, have to set up l_pivot_lookup.
+    l_pivot_lookup.resize(num_row);
+    for (HighsInt iRow = 0; iRow < num_row; iRow++) {
+      if (iRow < stage) {
+        if (l_pivot_lookup[l_pivot_index[iRow]] != iRow) {
+          // printf("Strange: Thought that l_pivot_lookup[l_pivot_index[iRow]]
+          // == iRow\n");
+        }
+      }
+      l_pivot_lookup[l_pivot_index[iRow]] = iRow;
+    }
+    // Need to know whether to consider matrix entries for FtranL
+    // operation. Initially these correspond to all the rows without
+    // pivots
+    vector<bool> not_in_bump = has_pivot;
+    // Monitor density of FtranL result to possibly switch from exploiting
+    // hyper-sparsity
+    double expected_density = 0.0;
+    // Initialise a HVector in which the L and U entries of the
+    // pivotal column will be formed
+    HVector column;
+    column.setup(num_row);
+    for (HighsInt iK = stage; iK < num_row; iK++) {
+      HighsInt iRow = this->refactor_info_.pivot_row[iK];
+      HighsInt iVar = this->refactor_info_.pivot_var[iK];
+      int8_t pivot_type = this->refactor_info_.pivot_type[iK];
+      assert(!has_pivot[iRow]);
+      assert(pivot_type == kPivotMarkowitz);
+      // Set up the column for the FtranL. It contains the matrix
+      // entries in rows without pivots, and the remaining entries
+      // start forming the U column
+      column.clear();
+      HighsInt start = a_start[iVar];
+      HighsInt end = a_start[iVar + 1];
+      for (HighsInt iEl = start; iEl < end; iEl++) {
+        HighsInt local_iRow = a_index[iEl];
+        if (not_in_bump[local_iRow]) {
+          u_index.push_back(local_iRow);
+          u_value.push_back(a_value[iEl]);
+        } else {
+          column.index[column.count++] = local_iRow;
+          column.array[local_iRow] = a_value[iEl];
+        }
+      }
+      // Perform FtranL, but don't time it!
+      ftranL(column, expected_density);
+      // Update the running average density
+      double local_density = (1.0 * column.count) / num_row;
+      expected_density = kRunningAverageMultiplier * local_density +
+                         (1 - kRunningAverageMultiplier) * expected_density;
+      // Strip out small values
+      column.tight();
+      // Now form the column of L
+      //
+      // Find the pivot
+      HighsInt pivot_k = -1;
+      start = 0;
+      end = column.count;
+      for (HighsInt k = start; k < end; k++) {
+        if (column.index[k] == iRow) {
+          pivot_k = k;
+          break;
+        }
+      }
+      assert(pivot_k >= 0);
+      // Check that the pivot isn't too small. Shouldn't happen since
+      // this is refactorization
+      double abs_pivot = std::fabs(column.array[iRow]);
+      assert(abs_pivot >= pivot_tolerance);
+      if (abs_pivot < pivot_tolerance) {
+        rank_deficiency = num_row - iK;
+        return rank_deficiency;
+      }
+      const double pivot_multiplier = 1 / column.array[iRow];
+      for (HighsInt section = 0; section < 2; section++) {
+        HighsInt p0 = section == 0 ? start : pivot_k + 1;
+        HighsInt p1 = section == 0 ? pivot_k : end;
+        for (HighsInt k = p0; k < p1; k++) {
+          HighsInt local_iRow = column.index[k];
+          if (!has_pivot[local_iRow]) {
+            l_index.push_back(local_iRow);
+            l_value.push_back(column.array[local_iRow] * pivot_multiplier);
+          } else {
+            u_index.push_back(local_iRow);
+            u_value.push_back(column.array[local_iRow]);
+          }
+        }
+      }
+      l_start[iK + 1] = l_index.size();
+      u_pivot_index.push_back(iRow);
+      u_pivot_value.push_back(column.array[iRow]);
+      u_start.push_back(u_index.size());
+      basic_index[iRow] = iVar;
+      has_pivot[iRow] = true;
+      if (report_lu) {
+        printf("\nAfter Markowitz %d\n", (int)(iK - stage));
+        reportLu(kReportLuBoth, false);
+      }
+    }
+  }
+  if (report_lu) {
+    printf("\nRefactored INVERT\n");
+    reportLu(kReportLuBoth, false);
+  }
+  buildFinish();
+  return 0;
+}

data/ext/lpsolver-highs/highs/util/HFactorUtils.cpp

@@ -0,0 +1,122 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file util/HFactorUtils.cpp
+ * @brief Types of solution classes
+ */
+#include "util/HFactor.h"
+
+void HFactor::invalidAMatrixAction() {
+  this->a_matrix_valid = false;
+  refactor_info_.clear();
+}
+
+void HFactor::reportLu(const HighsInt l_u_or_both, const bool full) const {
+  if (l_u_or_both < kReportLuJustL || l_u_or_both > kReportLuBoth) return;
+  if (l_u_or_both & 1) {
+    printf("L");
+    if (full) printf(" - full");
+    printf(":\n");
+
+    if (full) reportIntVector("l_pivot_lookup", l_pivot_lookup);
+    if (full) reportIntVector("l_pivot_index", l_pivot_index);
+    reportIntVector("l_start", l_start);
+    reportIntVector("l_index", l_index);
+    reportDoubleVector("l_value", l_value);
+    if (full) {
+      reportIntVector("lr_start", lr_start);
+      reportIntVector("lr_index", lr_index);
+      reportDoubleVector("lr_value", lr_value);
+    }
+  }
+  if (l_u_or_both & 2) {
+    printf("U");
+    if (full) printf(" - full");
+    printf(":\n");
+    if (full) reportIntVector("u_pivot_lookup", u_pivot_lookup);
+    reportIntVector("u_pivot_index", u_pivot_index);
+    reportDoubleVector("u_pivot_value", u_pivot_value);
+    reportIntVector("u_start", u_start);
+    if (full) reportIntVector("u_last_p", u_last_p);
+    reportIntVector("u_index", u_index);
+    reportDoubleVector("u_value", u_value);
+    if (full) {
+      reportIntVector("ur_start", ur_start);
+      reportIntVector("ur_lastp", ur_lastp);
+      reportIntVector("ur_space", ur_space);
+      for (size_t iRow = 0; iRow < ur_start.size(); iRow++) {
+        const HighsInt start = ur_start[iRow];
+        const HighsInt end = ur_lastp[iRow];
+        if (start >= end) continue;
+        printf("UR    Row %2d: ", (int)iRow);
+        for (HighsInt iEl = start; iEl < end; iEl++)
+          printf("%11d ", (int)ur_index[iEl]);
+        printf("\n              ");
+        for (HighsInt iEl = start; iEl < end; iEl++)
+          printf("%11.4g ", ur_value[iEl]);
+        printf("\n");
+      }
+      //      reportIntVector("ur_index", ur_index);
+      //      reportDoubleVector("ur_value", ur_value);
+    }
+  }
+  if (l_u_or_both == 3 && full) {
+    reportDoubleVector("pf_pivot_value", pf_pivot_value);
+    reportIntVector("pf_pivot_index", pf_pivot_index);
+    reportIntVector("pf_start", pf_start);
+    reportIntVector("pf_index", pf_index);
+    reportDoubleVector("pf_value", pf_value);
+  }
+}
+
+void HFactor::reportIntVector(const std::string name,
+                              const vector<HighsInt> entry) const {
+  const HighsInt num_en = entry.size();
+  printf("%-12s: siz %4d; cap %4d: ", name.c_str(), (int)num_en,
+         (int)entry.capacity());
+  for (HighsInt iEn = 0; iEn < num_en; iEn++) {
+    if (iEn > 0 && iEn % 10 == 0)
+      printf("\n                                  ");
+    printf("%11d ", (int)entry[iEn]);
+  }
+  printf("\n");
+}
+void HFactor::reportDoubleVector(const std::string name,
+                                 const vector<double> entry) const {
+  const HighsInt num_en = entry.size();
+  printf("%-12s: siz %4d; cap %4d: ", name.c_str(), (int)num_en,
+         (int)entry.capacity());
+  for (HighsInt iEn = 0; iEn < num_en; iEn++) {
+    if (iEn > 0 && iEn % 10 == 0)
+      printf("\n                                  ");
+    printf("%11.4g ", entry[iEn]);
+  }
+  printf("\n");
+}
+
+void HFactor::reportAsm() const {
+  for (HighsInt count = 1; count <= num_row; count++) {
+    if (col_link_first[count] < 0) continue;
+    for (HighsInt j = col_link_first[count]; j != -1; j = col_link_next[j]) {
+      double min_pivot = mc_min_pivot[j];
+      HighsInt start = mc_start[j];
+      HighsInt end = start + mc_count_a[j];
+      printf("Col %4d: count = %2d; min_pivot = %10.4g; [%4d, %4d)\n", (int)j,
+             (int)count, min_pivot, (int)start, (int)end);
+      for (HighsInt k = start; k < end; k++) {
+        HighsInt i = mc_index[k];
+        double value = mc_value[k];
+        //	if (abs_value < 1e-8) continue;
+        HighsInt row_count = mr_count[i];
+        double merit_local = 1.0 * (count - 1) * (row_count - 1);
+        printf("   Row %4d; Count = %2d; Merit = %11.4g; Value = %11.4g: %s\n",
+               (int)i, (int)row_count, merit_local, value,
+               std::abs(value) >= min_pivot ? "OK" : "");
+      }
+    }
+  }
+}

data/ext/lpsolver-highs/highs/util/HSet.cpp

@@ -0,0 +1,197 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file util/HSet.cpp
+ * @brief
+ */
+#include "util/HSet.h"
+
+#include <cassert>
+
+bool HSet::setup(const HighsInt size, const HighsInt max_entry,
+                 const bool output_flag, FILE* log_file, const bool debug,
+                 const bool allow_assert) {
+  setup_ = false;
+  if (size <= 0) return false;
+  if (max_entry < min_entry) return false;
+  max_entry_ = max_entry;
+  debug_ = debug;
+  allow_assert_ = allow_assert;
+  output_flag_ = output_flag;
+  log_file_ = log_file;
+  entry_.resize(size);
+  pointer_.assign(max_entry_ + 1, no_pointer);
+  count_ = 0;
+  setup_ = true;
+  return true;
+}
+
+void HSet::clear() {
+  if (!setup_) setup(1, 0);
+  pointer_.assign(max_entry_ + 1, no_pointer);
+  count_ = 0;
+  if (debug_) debug();
+}
+
+bool HSet::add(const HighsInt entry) {
+  if (entry < min_entry) return false;
+  if (!setup_) setup(1, entry);
+  if (entry > max_entry_) {
+    // Entry exceeds what's allowable so far so can't be in the list
+    pointer_.resize(entry + 1);
+    for (HighsInt ix = max_entry_ + 1; ix < entry; ix++)
+      pointer_[ix] = no_pointer;
+    max_entry_ = entry;
+  } else if (pointer_[entry] > no_pointer) {
+    // Duplicate
+    if (debug_) debug();
+    return false;
+  }
+  // New entry
+  HighsInt size = entry_.size();
+  if (count_ == size) {
+    size++;
+    entry_.resize(size);
+  }
+  pointer_[entry] = count_;
+  entry_[count_++] = entry;
+  if (debug_) debug();
+  return true;
+}
+
+bool HSet::remove(const HighsInt entry) {
+  if (!setup_) {
+    setup(1, 0);
+    if (debug_) debug();
+    return false;
+  }
+  if (entry < min_entry) return false;
+  if (entry > max_entry_) return false;
+  HighsInt pointer = pointer_[entry];
+  if (pointer == no_pointer) return false;
+  pointer_[entry] = no_pointer;
+  if (pointer < count_ - 1) {
+    HighsInt last_entry = entry_[count_ - 1];
+    entry_[pointer] = last_entry;
+    pointer_[last_entry] = pointer;
+  }
+  count_--;
+  if (debug_) debug();
+  return true;
+}
+
+bool HSet::in(const HighsInt entry) const {
+  if (entry < min_entry) return false;
+  if (entry > max_entry_) return false;
+  return pointer_[entry] != no_pointer;
+}
+
+bool HSet::debug() const {
+  if (!setup_) {
+    if (output_flag_) fprintf(log_file_, "HSet: ERROR setup_ not called\n");
+    if (allow_assert_) assert(setup_);
+    return false;
+  }
+  bool max_entry_ok = max_entry_ >= min_entry;
+  if (!max_entry_ok) {
+    if (output_flag_) {
+      fprintf(log_file_,
+              "HSet: ERROR max_entry_ = %" HIGHSINT_FORMAT
+              " < %" HIGHSINT_FORMAT "\n",
+              max_entry_, min_entry);
+      print();
+    }
+    if (allow_assert_) assert(max_entry_ok);
+    return false;
+  }
+  HighsInt size = entry_.size();
+  bool size_count_ok = size >= count_;
+  if (!size_count_ok) {
+    if (output_flag_) {
+      fprintf(log_file_,
+              "HSet: ERROR entry_.size() = %" HIGHSINT_FORMAT
+              " is less than count_ = %" HIGHSINT_FORMAT "\n",
+              size, count_);
+      print();
+    }
+    if (allow_assert_) assert(size_count_ok);
+    return false;
+  }
+  // Check pointer_ is consistent with count_ and entry_
+  HighsInt count = 0;
+  for (HighsInt ix = 0; ix <= max_entry_; ix++) {
+    HighsInt pointer = pointer_[ix];
+    if (pointer == no_pointer) continue;
+    bool pointer_ok = pointer >= 0 && pointer < count_;
+    if (!pointer_ok) {
+      if (output_flag_) {
+        fprintf(log_file_,
+                "HSet: ERROR pointer_[%" HIGHSINT_FORMAT "] = %" HIGHSINT_FORMAT
+                " is not in [0, %" HIGHSINT_FORMAT "]\n",
+                ix, pointer, count_);
+        print();
+      }
+      if (allow_assert_) assert(pointer_ok);
+      return false;
+    }
+    count++;
+    HighsInt entry = entry_[pointer];
+    bool entry_ok = entry == ix;
+    if (!entry_ok) {
+      if (output_flag_) {
+        fprintf(log_file_,
+                "HSet: ERROR entry_[%" HIGHSINT_FORMAT "] is %" HIGHSINT_FORMAT
+                ", not %" HIGHSINT_FORMAT "\n",
+                pointer, entry, ix);
+        print();
+      }
+      if (allow_assert_) assert(entry_ok);
+      return false;
+    }
+  }
+  bool count_ok = count == count_;
+  if (!count_ok) {
+    if (output_flag_) {
+      fprintf(log_file_,
+              "HSet: ERROR pointer_ has %" HIGHSINT_FORMAT
+              " pointers, not %" HIGHSINT_FORMAT "\n",
+              count, count_);
+      print();
+    }
+    if (allow_assert_) assert(count_ok);
+    return false;
+  }
+  return true;
+}
+
+void HSet::print() const {
+  if (!setup_) return;
+  if (log_file_ == NULL) return;
+  HighsInt size = entry_.size();
+  fprintf(log_file_, "\nSet(%" HIGHSINT_FORMAT ", %" HIGHSINT_FORMAT "):\n",
+          size, max_entry_);
+  fprintf(log_file_, "Pointers: Pointers|");
+  for (HighsInt ix = 0; ix <= max_entry_; ix++) {
+    if (pointer_[ix] != no_pointer)
+      fprintf(log_file_, " %4" HIGHSINT_FORMAT "", pointer_[ix]);
+  }
+  fprintf(log_file_, "\n");
+  fprintf(log_file_, "          Entries |");
+  for (HighsInt ix = 0; ix <= max_entry_; ix++) {
+    if (pointer_[ix] != no_pointer)
+      fprintf(log_file_, " %4" HIGHSINT_FORMAT "", ix);
+  }
+  fprintf(log_file_, "\n");
+  fprintf(log_file_, "Entries:  Indices |");
+  for (HighsInt ix = 0; ix < count_; ix++)
+    fprintf(log_file_, " %4" HIGHSINT_FORMAT "", ix);
+  fprintf(log_file_, "\n");
+  fprintf(log_file_, "          Entries |");
+  for (HighsInt ix = 0; ix < count_; ix++)
+    fprintf(log_file_, " %4" HIGHSINT_FORMAT "", entry_[ix]);
+  fprintf(log_file_, "\n");
+}