lpsolver 0.1.0 → 0.2.1

data/ext/lpsolver-highs/build/include/highs/simplex/HEkkDualRow.h

@@ -0,0 +1,201 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file simplex/HEkkDualRow.h
+ * @brief Dual simplex ratio test for HiGHS
+ */
+#ifndef SIMPLEX_HEKKDUALROW_H_
+#define SIMPLEX_HEKKDUALROW_H_
+
+#include <set>
+#include <vector>
+
+#include "simplex/HEkk.h"
+#include "util/HVector.h"
+
+const double kInitialTotalChange = 1e-12;
+const double kInitialRemainTheta = 1e100;
+const double kMaxSelectTheta = 1e18;
+
+/**
+ * @brief Dual simplex ratio test for HiGHS
+ *
+ * Performs the dual bound-flipping ratio test and some update
+ * dual/flip tasks
+ */
+class HEkkDualRow {
+ public:
+  HEkkDualRow(HEkk& simplex) : ekk_instance_(simplex) {}
+
+  /**
+   * @brief Calls setupSlice to set up the packed indices and values for
+   * the dual ratio test
+   */
+  void setup();
+
+  /**
+   * @brief Set up the packed indices and values for the dual ratio test
+   *
+   * Done either for the whole pivotal row (see HEkkDualRow::setup), or
+   * just for a slice (see HEkkDual::initSlice)
+   */
+  void setupSlice(HighsInt size  //!< Dimension of slice
+  );
+  /**
+   * @brief Clear the packed data by zeroing packCount and workCount
+   */
+  void clear();
+
+  /**
+   * @brief Pack the indices and values for the row.
+   *
+   * Offset of numCol is used when packing row_ep
+   */
+  void chooseMakepack(const HVector* row,    //!< Row to be packed
+                      const HighsInt offset  //!< Offset for indices
+  );
+  /**
+   * @brief Determine the possible variables - candidates for CHUZC
+   *
+   * TODO: Check with Qi what this is doing
+   */
+  void choosePossible();
+
+  /**
+   * @brief Join pack of possible candidates in this row with possible
+   * candidates in otherRow
+   */
+  void chooseJoinpack(
+      const HEkkDualRow* otherRow  //!< Other row to join with this
+  );
+  /**
+   * @brief Chooses the entering variable via BFRT and EXPAND
+   *
+   * Can fail when there are excessive dual values due to EXPAND
+   * perturbation not being relatively too small, returns positive if
+   * dual unboundedness is suspected
+   */
+  HighsInt chooseFinal();
+
+  /**
+   * @brief Identifies the groups of degenerate nodes in BFRT after a
+   * heap sort of ratios
+   */
+  bool chooseFinalWorkGroupQuad();
+  bool quadChooseFinalWorkGroupQuad();
+  bool chooseFinalWorkGroupHeap();
+
+  void chooseFinalLargeAlpha(
+      HighsInt& breakIndex, HighsInt& breakGroup, HighsInt pass_workCount,
+      const std::vector<std::pair<HighsInt, double>>& pass_workData,
+      const std::vector<HighsInt>& pass_workGroup);
+
+  void reportWorkDataAndGroup(
+      const std::string message, const HighsInt reportWorkCount,
+      const std::vector<std::pair<HighsInt, double>>& reportWorkData,
+      const std::vector<HighsInt>& reportWorkGroup);
+  bool compareWorkDataAndGroup();
+
+  /**
+   * @brief Update bounds when flips have occurred, and accumulate the
+   * RHS for the FTRAN required to update the primal values after BFRT
+   */
+  void updateFlip(HVector* bfrtColumn  //!< RHS for FTRAN BFRT
+  );
+  /**
+   * @brief Update the dual values
+   */
+  void updateDual(
+      double theta  //!< Multiple of pivotal row to add HighsInt to duals
+                    //      HighsInt variable_out  //!< Index of leaving column
+  );
+  /**
+   * @brief Create a list of nonbasic free columns
+   */
+  void createFreelist();
+
+  /**
+   * @brief Set a value of nonbasicMove for all free columns to
+   * prevent their dual values from being changed
+   */
+  void createFreemove(HVector* row_ep  //!< Row of \f$B^{-1}\f$ to be used to
+                                       //!< compute pivotal row entry
+  );
+  /**
+   * @brief Reset the nonbasicMove values for free columns
+   */
+  void deleteFreemove();
+
+  /**
+   * @brief Delete the list of nonbasic free columns
+   */
+  void deleteFreelist(
+      HighsInt iColumn  //!< Index of column to remove from Freelist
+  );
+
+  /**
+   * @brief Compute (contribution to) the Devex weight
+   */
+  void computeDevexWeight(const HighsInt slice = -1);
+
+  HighsInt debugFindInWorkData(
+      const HighsInt iCol, const HighsInt count,
+      const std::vector<std::pair<HighsInt, double>>& workData_) const;
+  HighsInt debugChooseColumnInfeasibilities() const;
+  void debugReportBfrtVar(
+      const HighsInt ix,
+      const std::vector<std::pair<HighsInt, double>>& pass_workData) const;
+  // References:
+  HEkk& ekk_instance_;
+
+  HighsInt workSize = -1;  //!< Size of the HEkkDualRow slice: Initialise it
+                           //!< here to avoid compiler warning
+  const HighsInt* workNumTotPermutation =
+      nullptr;  //!< Pointer to ekk_instance_.numTotPermutation();
+  const int8_t* workMove =
+      nullptr;  //!< Pointer to ekk_instance_.basis_.nonbasicMove_;
+  const double* workDual =
+      nullptr;  //!< Pointer to ekk_instance_.info_.workDual_;
+  const double* workRange =
+      nullptr;  //!< Pointer to ekk_instance_.info_.workRange_;
+  const HighsInt* work_devex_index =
+      nullptr;  //!< Pointer to
+                //!< ekk_instance_.info_.devex_index_;
+
+  // Freelist:
+  std::set<HighsInt> freeList;  //!< Freelist itself
+
+  // packed data:
+  HighsInt packCount = 0;           //!< number of packed indices/values
+  std::vector<HighsInt> packIndex;  //!< Packed indices
+  std::vector<double> packValue;    //!< Packed values
+
+  // (Local) value of computed weight
+  double computed_edge_weight = 0.;
+
+  double workDelta = 0.;   //!< Local copy of dual.delta_primal
+  double workAlpha = 0.;   //!< Original copy of pivotal computed row-wise
+  double workTheta = 0.;   //!< Original copy of dual step workDual[workPivot] /
+                           //!< workAlpha;
+  HighsInt workPivot = 0;  //!< Index of the column entering the basis
+  HighsInt workCount = 0;  //!< Number of BFRT flips
+
+  std::vector<std::pair<HighsInt, double>>
+      workData;  //!< Index-Value pairs for ratio test
+  std::vector<HighsInt>
+      workGroup;  //!< Pointers into workData for degenerate nodes in BFRT
+
+  // Independent identifiers for heap-based sort in BFRT
+  HighsInt alt_workCount = 0;
+  std::vector<std::pair<HighsInt, double>> original_workData;
+  std::vector<std::pair<HighsInt, double>> sorted_workData;
+  std::vector<HighsInt> alt_workGroup;
+
+  HighsSimplexAnalysis* analysis = nullptr;
+};
+
+#endif /* SIMPLEX_HEKKDUALROW_H_ */

data/ext/lpsolver-highs/build/include/highs/simplex/HEkkPrimal.h

@@ -0,0 +1,191 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file simplex/HEkkPrimal.h
+ * @brief Phase 2 primal simplex solver for HiGHS
+ */
+#ifndef SIMPLEX_HEKKPRIMAL_H_
+#define SIMPLEX_HEKKPRIMAL_H_
+
+#include <utility>
+
+#include "simplex/HEkk.h"
+#include "util/HSet.h"
+
+using std::pair;
+
+const SimplexAlgorithm algorithm = SimplexAlgorithm::kPrimal;
+
+/**
+ * @brief Primal simplex solver for HiGHS
+ */
+
+class HEkkPrimal {
+ public:
+  HEkkPrimal(HEkk& simplex) : ekk_instance_(simplex) { initialiseInstance(); }
+  /**
+   * @brief Solve a model instance
+   */
+  HighsStatus solve(const bool force_phase2 = false);
+
+ private:
+  /**
+   * @brief Initialise a primal simplex instance
+   */
+  void initialiseInstance();
+  /**
+   * @brief Initialise a primal simplex solve
+   */
+  void initialiseSolve();
+  void solvePhase1();
+  void solvePhase2();
+  void cleanup();
+  void rebuild();
+
+  void iterate();
+  void chuzc();
+  void chooseColumn(const bool hyper_sparse = false);
+  bool useVariableIn();
+  void phase1ChooseRow();
+  void chooseRow();
+
+  void considerBoundSwap();
+  void assessPivot();
+
+  void update();
+
+  void updateDual();
+
+  void hyperChooseColumn();
+  void hyperChooseColumnStart();
+  void hyperChooseColumnClear();
+  void hyperChooseColumnChangedInfeasibility(const double infeasibility,
+                                             const HighsInt iCol);
+  void hyperChooseColumnBasicFeasibilityChange();
+  void hyperChooseColumnDualChange();
+
+  void phase1ComputeDual();
+  void phase1UpdatePrimal();
+  void basicFeasibilityChangeBtran();
+  void basicFeasibilityChangePrice();
+  void basicFeasibilityChangeUpdateDual();
+
+  void phase2UpdatePrimal(const bool initialise = false);
+
+  void considerInfeasibleValueIn();
+
+  void initialiseDevexFramework();
+  void updateDevex();
+  void computePrimalSteepestEdgeWeights();
+  double computePrimalSteepestEdgeWeight(const HighsInt iVar,
+                                         HVector& local_col_aq);
+  void updatePrimalSteepestEdgeWeights();
+  void updateDualSteepestEdgeWeights();
+  void updateFtranDSE(HVector& col_steepest_edge);
+  void updateBtranPSE(HVector& col_steepest_edge);
+
+  void updateVerify();
+
+  void iterationAnalysisData();
+  void iterationAnalysis();
+  void localReportIterHeader();
+  void localReportIter(const bool header = false);
+  void reportRebuild(const HighsInt reason_for_rebuild = -1);
+  void getNonbasicFreeColumnSet();
+  void removeNonbasicFreeColumn();
+  void adjustPerturbedEquationOut();
+  void getBasicPrimalInfeasibility();
+  bool correctPrimal(const bool initialise = false);
+  void shiftBound(const bool lower, const HighsInt iVar, const double value,
+                  const double random_value, double& bound, double& shift);
+  void savePrimalRay();
+  HighsDebugStatus debugPrimalSimplex(const std::string message,
+                                      const bool initialise = false);
+  HighsDebugStatus debugPrimalSteepestEdgeWeights(const std::string message);
+  HighsDebugStatus debugPrimalSteepestEdgeWeights(
+      const HighsInt alt_debug_level = -1);
+
+  bool isBadBasisChange();
+
+  // References:
+  HEkk& ekk_instance_;
+
+  // Pointers:
+  HighsSimplexAnalysis* analysis;
+
+  // Class data members
+  HighsInt num_col;
+  HighsInt num_row;
+  HighsInt num_tot;
+  HighsInt solve_phase;
+  EdgeWeightMode edge_weight_mode;
+  double primal_feasibility_tolerance;
+  double dual_feasibility_tolerance;
+  double objective_target;
+  HighsInt rebuild_reason;
+  // Pivot related
+  HighsInt variable_in;
+  HighsInt move_in;
+  HighsInt row_out;
+  HighsInt variable_out;
+  HighsInt move_out;
+  double theta_dual;
+  double theta_primal;
+  double value_in;
+  double alpha_col;
+  double alpha_row;
+  double numericalTrouble;
+
+  HighsInt num_flip_since_rebuild;
+  // Primal phase 1 tools
+  vector<pair<double, HighsInt>> ph1SorterR;
+  vector<pair<double, HighsInt>> ph1SorterT;
+  // Edge weights
+  // Edge weight
+  vector<double> edge_weight_;
+  HighsInt num_devex_iterations_;
+  HighsInt num_bad_devex_weight_;
+  vector<HighsInt> devex_index_;
+  // Nonbasic free column data.
+  HighsInt num_free_col;
+  HSet nonbasic_free_col_set;
+  // Hyper-sparse CHUZC data
+  bool use_hyper_chuzc = false;
+  bool initialise_hyper_chuzc;
+  bool done_next_chuzc;
+  const HighsInt max_num_hyper_chuzc_candidates = 50;
+  HighsInt num_hyper_chuzc_candidates;
+  vector<HighsInt> hyper_chuzc_candidate;
+  vector<double> hyper_chuzc_measure;
+  HSet hyper_chuzc_candidate_set;
+  double max_hyper_chuzc_non_candidate_measure;
+  double max_changed_measure_value;
+  HighsInt max_changed_measure_column;
+  const bool report_hyper_chuzc = false;
+  // Solve buffer
+  HVector row_ep;
+  HVector row_ap;
+  HVector col_aq;
+  HVector col_basic_feasibility_change;
+  HVector row_basic_feasibility_change;
+  HVector col_steepest_edge;
+  HighsRandom random_;  // Just for checking PSE weights
+
+  double max_max_local_primal_infeasibility_;
+  double max_max_ignored_violation_;
+  double max_max_primal_correction_;
+  HighsInt last_header_iteration_count_;
+
+  const HighsInt primal_correction_strategy =
+      kSimplexPrimalCorrectionStrategyAlways;
+  double debug_max_relative_primal_steepest_edge_weight_error = 0;
+
+  const HighsInt check_iter = 9999999;
+  const HighsInt check_column = -2133;
+};
+
+#endif /* SIMPLEX_HEKKPRIMAL_H_ */

data/ext/lpsolver-highs/build/include/highs/simplex/HSimplex.h

@@ -0,0 +1,42 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file lp_data/HSimplex.h
+ * @brief
+ */
+#ifndef SIMPLEX_HSIMPLEX_H_
+#define SIMPLEX_HSIMPLEX_H_
+
+#include "lp_data/HighsInfo.h"
+#include "lp_data/HighsLp.h"
+
+void appendNonbasicColsToBasis(HighsLp& lp, HighsBasis& highs_basis,
+                               HighsInt XnumNewCol);
+void appendNonbasicColsToBasis(HighsLp& lp, SimplexBasis& basis,
+                               HighsInt XnumNewCol);
+
+void appendBasicRowsToBasis(HighsLp& lp, HighsBasis& highs_basis,
+                            HighsInt XnumNewRow);
+void appendBasicRowsToBasis(HighsLp& lp, SimplexBasis& basis,
+                            HighsInt XnumNewRow);
+
+void getUnscaledInfeasibilities(const HighsOptions& options,
+                                const HighsScale& scale,
+                                const SimplexBasis& basis,
+                                const HighsSimplexInfo& info,
+                                HighsInfo& highs_info);
+
+void setSolutionStatus(HighsInfo& highs_info);
+// SCALE:
+
+void scaleSimplexCost(const HighsOptions& options, HighsLp& lp,
+                      double& cost_scale);
+void unscaleSimplexCost(HighsLp& lp, double cost_scale);
+
+bool isBasisRightSize(const HighsLp& lp, const SimplexBasis& basis);
+
+#endif  // SIMPLEX_HSIMPLEX_H_

data/ext/lpsolver-highs/build/include/highs/simplex/HSimplexDebug.h

@@ -0,0 +1,48 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file lp_data/HSimplexDebug.h
+ * @brief
+ */
+#ifndef SIMPLEX_HSIMPLEXDEBUG_H_
+#define SIMPLEX_HSIMPLEXDEBUG_H_
+
+#include <set>
+
+#include "lp_data/HighsLpSolverObject.h"
+
+// Methods for Ekk
+
+void debugDualChuzcFailNorms(
+    const HighsInt workCount,
+    const std::vector<std::pair<HighsInt, double>>& workData,
+    double& workDataNorm, const HighsInt numVar, const double* workDual,
+    double& workDualNorm);
+
+HighsDebugStatus debugDualChuzcFailQuad0(
+    const HighsOptions& options, const HighsInt workCount,
+    const std::vector<std::pair<HighsInt, double>>& workData,
+    const HighsInt numVar, const double* workDual, const double selectTheta,
+    const double remainTheta, const bool force = false);
+
+HighsDebugStatus debugDualChuzcFailQuad1(
+    const HighsOptions& options, const HighsInt workCount,
+    const std::vector<std::pair<HighsInt, double>>& workData,
+    const HighsInt numVar, const double* workDual, const double selectTheta,
+    const bool force = false);
+
+HighsDebugStatus debugDualChuzcFailHeap(
+    const HighsOptions& options, const HighsInt workCount,
+    const std::vector<std::pair<HighsInt, double>>& workData,
+    const HighsInt numVar, const double* workDual, const double selectTheta,
+    const bool force = false);
+
+HighsDebugStatus debugNonbasicFlagConsistent(const HighsOptions& options,
+                                             const HighsLp& lp,
+                                             const SimplexBasis& basis);
+
+#endif  // SIMPLEX_HSIMPLEXDEBUG_H_

data/ext/lpsolver-highs/build/include/highs/simplex/HSimplexNla.h

@@ -0,0 +1,158 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file simplex/HSimplexNla.h
+ *
+ * @brief Interface to HFactor allowing non-HFactor updates, NLA-only
+ * scaling and shifting of NLA analysis below simplex level.
+ */
+#ifndef HSIMPLEXNLA_H_
+#define HSIMPLEXNLA_H_
+
+#include "lp_data/HighsDebug.h"
+#include "simplex/HighsSimplexAnalysis.h"
+#include "simplex/SimplexStruct.h"
+#include "util/HFactor.h"
+
+const HighsInt kReportItemLimit = 25;
+const double kDensityForIndexing = 0.4;
+
+struct ProductFormUpdate {
+  bool valid_ = false;
+  HighsInt num_row_;
+  HighsInt update_count_;
+  vector<HighsInt> pivot_index_;
+  vector<double> pivot_value_;
+  vector<HighsInt> start_;
+  vector<HighsInt> index_;
+  vector<double> value_;
+  void clear();
+  void setup(const HighsInt num_row, const double expected_density);
+  HighsInt update(HVector* aq, HighsInt* iRow);
+  void btran(HVector& rhs) const;
+  void ftran(HVector& rhs) const;
+};
+
+struct SimplexIterate {
+  bool valid_ = false;
+  SimplexBasis basis_;
+  InvertibleRepresentation invert_;
+  std::vector<double> dual_edge_weight_;
+  void clear();
+};
+
+class HSimplexNla {
+ private:
+  void setup(const HighsLp* lp, HighsInt* basic_index,
+             const HighsOptions* options, HighsTimer* timer,
+             HighsSimplexAnalysis* analysis,
+             const HighsSparseMatrix* factor_a_matrix,
+             const double factor_pivot_threshold);
+
+  void setLpAndScalePointers(const HighsLp* lp);
+  void setBasicIndexPointers(HighsInt* basic_index);
+  void setPointers(const HighsLp* for_lp,
+                   const HighsSparseMatrix* factor_a_matrix = NULL,
+                   HighsInt* basic_index = NULL,
+                   const HighsOptions* options = NULL, HighsTimer* timer = NULL,
+                   HighsSimplexAnalysis* analysis = NULL);
+  void clear();
+  HighsInt invert();
+  void btran(HVector& rhs, const double expected_density,
+             HighsTimerClock* factor_timer_clock_pointer = NULL) const;
+  void ftran(HVector& rhs, const double expected_density,
+             HighsTimerClock* factor_timer_clock_pointer = NULL) const;
+  void btranInScaledSpace(
+      HVector& rhs, const double expected_density,
+      HighsTimerClock* factor_timer_clock_pointer = NULL) const;
+  void ftranInScaledSpace(
+      HVector& rhs, const double expected_density,
+      HighsTimerClock* factor_timer_clock_pointer = NULL) const;
+  void update(HVector* aq, HVector* ep, HighsInt* iRow, HighsInt* hint);
+
+  void putInvert();
+  void getInvert();
+
+  void transformForUpdate(HVector* column, HVector* row_ep,
+                          const HighsInt variable_in, const HighsInt row_out);
+  double variableScaleFactor(const HighsInt iVar) const;
+  double basicColScaleFactor(const HighsInt iCol) const;
+  double pivotInScaledSpace(const HVector* aq, const HighsInt variable_in,
+                            const HighsInt row_out) const;
+  void setPivotThreshold(const double new_pivot_threshold);
+
+  void passLpPointer(const HighsLp* lp);
+  void passScalePointer(const HighsScale* scale);
+  void applyBasisMatrixColScale(HVector& rhs) const;
+  void applyBasisMatrixRowScale(HVector& rhs) const;
+  void unapplyBasisMatrixRowScale(HVector& rhs) const;
+  double rowEp2NormInScaledSpace(const HighsInt iRow,
+                                 const HVector& row_ep) const;
+  void addCols(const HighsLp* updated_lp);
+  void addRows(const HighsLp* updated_lp, HighsInt* basic_index,
+               const HighsSparseMatrix* scaled_ar_matrix);
+  bool sparseLoopStyle(const HighsInt count, const HighsInt dim,
+                       HighsInt& to_entry) const;
+  void reportVector(const std::string message, const HighsInt num_index,
+                    const vector<double> vector_value,
+                    const vector<HighsInt> vector_index,
+                    const bool force) const;
+  void reportArray(const std::string message, const HVector* vector,
+                   const bool force = false) const;
+  void reportArray(const std::string message, const HighsInt offset,
+                   const HVector* vector, const bool force = false) const;
+  void reportArraySparse(const std::string message, const HVector* vector,
+                         const bool force = false) const;
+  void reportArraySparse(const std::string message, const HighsInt offset,
+                         const HVector* vector, const bool force = false) const;
+  void reportPackValue(const std::string message, const HVector* vector,
+                       const bool force = false) const;
+  // Debug methods
+  HighsDebugStatus debugCheckData(const std::string message = "") const;
+  HighsDebugStatus debugCheckInvert(const std::string message,
+                                    const HighsInt alt_debug_level = -1) const;
+  double debugInvertResidualError(const bool transposed,
+                                  const HVector& solution,
+                                  HVector& residual) const;
+  HighsDebugStatus debugReportInvertSolutionError(const bool transposed,
+                                                  const HVector& true_solution,
+                                                  const HVector& solution,
+                                                  HVector& residual,
+                                                  const bool force) const;
+  HighsDebugStatus debugReportInvertSolutionError(
+      const std::string source, const bool transposed,
+      const double solve_error_norm, const double residual_error_norm,
+      const bool force) const;
+
+  // References:
+  //
+  // Pointers:
+
+  // Class data members
+  const HighsLp* lp_;
+  const HighsScale* scale_;
+  HighsInt* basic_index_;
+  const HighsOptions* options_;
+  HighsTimer* timer_;
+  HighsSimplexAnalysis* analysis_;
+
+  HFactor factor_;
+
+  bool report_;
+  double build_synthetic_tick_;
+
+  ProductFormUpdate update_;
+
+  // Simplex iterate data
+  SimplexIterate simplex_iterate_;
+
+  friend class HEkk;
+  friend class HEkkPrimal;
+  friend class HEkkDual;
+};
+
+#endif /* HSIMPLEXNLA_H_ */

data/ext/lpsolver-highs/build/include/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_