Update HiGHS header file to 1.9.0

Author: metab0t

thirdparty/solvers/highs/HConfig.h

@@ -12,10 +12,10 @@
 /* #undef HIGHS_HAVE_BUILTIN_CLZ */
 #define HIGHS_HAVE_BITSCAN_REVERSE
 
-#define HIGHS_GITHASH "4a7f24ac6"
+#define HIGHS_GITHASH "66f735e60"
 #define HIGHS_VERSION_MAJOR 1
-#define HIGHS_VERSION_MINOR 8
-#define HIGHS_VERSION_PATCH 1
+#define HIGHS_VERSION_MINOR 9
+#define HIGHS_VERSION_PATCH 0
 #define HIGHS_DIR "E:/HiGHS"
 
 #endif /* HCONFIG_H_ */

thirdparty/solvers/highs/Highs.h

@@ -150,6 +150,24 @@ class Highs {
   HighsStatus passHessian(const HighsInt dim, const HighsInt num_nz,
                           const HighsInt format, const HighsInt* start,
                           const HighsInt* index, const double* value);
+  /**
+   * @brief Pass multiple linear objectives for the incumbent model
+   */
+  HighsStatus passLinearObjectives(
+      const HighsInt num_linear_objective,
+      const HighsLinearObjective* linear_objective);
+
+  /**
+   * @brief Add a linear objective for the incumbent model
+   */
+  HighsStatus addLinearObjective(const HighsLinearObjective& linear_objective,
+                                 const HighsInt iObj = -1);
+
+  /**
+   * @brief Clear the multiple linear objective data
+   */
+  HighsStatus clearLinearObjectives();
+
   /**
    * @brief Pass a column name to the incumbent model
    */
@@ -183,7 +201,7 @@ class Highs {
   HighsStatus presolve();
 
   /**
-   * @brief Solve the incumbent model according to the specified options
+   * @brief Run the solver, accounting for any multiple objective
    */
   HighsStatus run();
 
@@ -1197,6 +1215,14 @@ class Highs {
   static void resetGlobalScheduler(bool blocking = false);
 
   // Start of advanced methods for HiGHS MIP solver
+
+  const HighsSimplexStats& getSimplexStats() const {
+    return ekk_instance_.getSimplexStats();
+  }
+  void reportSimplexStats(FILE* file) const {
+    ekk_instance_.reportSimplexStats(file);
+  }
+
   /**
    * @brief Get the hot start basis data from the most recent simplex
    * solve. Advanced method: for HiGHS MIP solver
@@ -1389,6 +1415,8 @@ class Highs {
   ICrashInfo icrash_info_;
 
   HighsModel model_;
+  std::vector<HighsLinearObjective> multi_linear_objective_;
+
   HighsModel presolved_model_;
   HighsTimer timer_;
 
@@ -1397,7 +1425,6 @@ class Highs {
   HighsInfo info_;
   HighsRanging ranging_;
   HighsIis iis_;
-
   std::vector<HighsObjectiveSolution> saved_objective_and_solution_;
 
   HighsPresolveStatus model_presolve_status_ =
@@ -1424,6 +1451,8 @@ class Highs {
 
   bool written_log_header = false;
 
+  HighsStatus solve();
+
   void exactResizeModel() {
     this->model_.lp_.exactResize();
     this->model_.hessian_.exactResize();
@@ -1600,6 +1629,10 @@ class Highs {
                          HighsInt* iis_col_index, HighsInt* iis_row_index,
                          HighsInt* iis_col_bound, HighsInt* iis_row_bound);
 
+  HighsStatus returnFromLexicographicOptimization(
+      const HighsStatus return_status, HighsInt original_lp_num_row);
+  HighsStatus multiobjectiveSolve();
+
   bool aFormatOk(const HighsInt num_nz, const HighsInt format);
   bool qFormatOk(const HighsInt num_nz, const HighsInt format);
   void clearZeroHessian();
@@ -1623,6 +1656,10 @@ class Highs {
                               const bool constraint,
                               const double ill_conditioning_bound);
   bool infeasibleBoundsOk();
+  bool validLinearObjective(const HighsLinearObjective& linear_objective,
+                            const HighsInt iObj) const;
+  bool hasRepeatedLinearObjectivePriorities(
+      const HighsLinearObjective* linear_objective = nullptr) const;
 };
 
 // Start of deprecated methods not in the Highs class

thirdparty/solvers/highs/interfaces/highs_c_api.h

@@ -557,6 +557,72 @@ HighsInt Highs_passHessian(void* highs, const HighsInt dim,
                            const HighsInt* start, const HighsInt* index,
                            const double* value);
 
+/**
+ * Passes multiple linear objective data to HiGHS, clearing any such
+ * data already in HiGHS
+ *
+ * @param highs         A pointer to the Highs instance.
+ * @param weight        A pointer to the weights of the linear objective, with
+ *                      its positive/negative sign determining whether it is
+ *                      minimized or maximized during lexicographic optimization
+ * @param offset        A pointer to the objective offsets
+ * @param coefficients  A pointer to the objective coefficients
+ * @param abs_tolerance A pointer to the absolute tolerances used when
+ *                      constructing objective constraints during lexicographic
+ *                      optimization
+ * @param rel_tolerance A pointer to the relative tolerances used when
+ *                      constructing objective constraints during lexicographic
+ *                      optimization
+ * @param priority      A pointer to the priorities of the objectives during
+ *                      lexicographic optimization
+ *
+ * @returns A `kHighsStatus` constant indicating whether the call succeeded.
+ */
+
+HighsInt Highs_passLinearObjectives(const void* highs,
+                                    const HighsInt num_linear_objective,
+                                    const double* weight, const double* offset,
+                                    const double* coefficients,
+                                    const double* abs_tolerance,
+                                    const double* rel_tolerance,
+                                    const HighsInt* priority);
+
+/**
+ * Adds linear objective data to HiGHS
+ *
+ * @param highs         A pointer to the Highs instance.
+ * @param weight        The weight of the linear objective, with its
+ *                      positive/negative sign determining whether it is
+ *                      minimized or maximized during lexicographic
+ *                      optimization
+ * @param offset        The objective offset
+ * @param coefficients  A pointer to the objective coefficients
+ * @param abs_tolerance The absolute tolerance used when constructing an
+ *                      objective constraint during lexicographic optimization
+ * @param rel_tolerance The relative tolerance used when constructing an
+ *                      objective constraint during lexicographic optimization
+ * @param priority      The priority of this objective during lexicographic
+ *                      optimization
+ *
+ * @returns A `kHighsStatus` constant indicating whether the call succeeded.
+ */
+
+HighsInt Highs_addLinearObjective(const void* highs, const double weight,
+                                  const double offset,
+                                  const double* coefficients,
+                                  const double abs_tolerance,
+                                  const double rel_tolerance,
+                                  const HighsInt priority);
+
+/**
+ * Clears any multiple linear objective data in HiGHS
+ *
+ * @param highs A pointer to the Highs instance.
+ *
+ * @returns A `kHighsStatus` constant indicating whether the call succeeded.
+ */
+
+HighsInt Highs_clearLinearObjectives(const void* highs);
 /**
  * Pass the name of a row.
  *
@@ -945,7 +1011,7 @@ HighsInt Highs_getDualRay(const void* highs, HighsInt* has_dual_ray,
  *                                                filled with the unboundedness
  *                                                direction.
  */
-HighsInt getDualUnboundednessDirection(
+HighsInt Highs_getDualUnboundednessDirection(
     const void* highs, HighsInt* has_dual_unboundedness_direction,
     double* dual_unboundedness_direction_value);
 

thirdparty/solvers/highs/lp_data/HStruct.h

@@ -144,4 +144,28 @@ struct HighsIllConditioning {
   void clear();
 };
 
+struct HighsLinearObjective {
+  double weight;
+  double offset;
+  std::vector<double> coefficients;
+  double abs_tolerance;
+  double rel_tolerance;
+  HighsInt priority;
+  void clear();
+};
+
+struct HighsSimplexStats {
+  bool valid;
+  HighsInt iteration_count;
+  HighsInt num_invert;
+  HighsInt last_invert_num_el;
+  HighsInt last_factored_basis_num_el;
+  double col_aq_density;
+  double row_ep_density;
+  double row_ap_density;
+  double row_DSE_density;
+  void report(FILE* file, const std::string message = "") const;
+  void initialise(const HighsInt iteration_count_ = 0);
+};
+
 #endif /* LP_DATA_HSTRUCT_H_ */

thirdparty/solvers/highs/lp_data/HighsOptions.h

@@ -348,6 +348,9 @@ struct HighsOptionsStruct {
   // Options for IIS calculation
   HighsInt iis_strategy;
 
+  // Option for multi-objective optimization
+  bool blend_multi_objectives;
+
   // Advanced options
   HighsInt log_dev_level;
   bool log_githash;
@@ -485,6 +488,8 @@ struct HighsOptionsStruct {
         pdlp_d_gap_tol(0.0),
         qp_iteration_limit(0),
         qp_nullspace_limit(0),
+        iis_strategy(0),
+        blend_multi_objectives(false),
         log_dev_level(0),
         log_githash(false),
         solve_relaxation(false),
@@ -1120,6 +1125,12 @@ class HighsOptions : public HighsOptionsStruct {
         kIisStrategyMax);
     records.push_back(record_int);
 
+    record_bool = new OptionRecordBool(
+        "blend_multi_objectives",
+        "Blend multiple objectives or apply lexicographically: Default = true",
+        advanced, &blend_multi_objectives, true);
+    records.push_back(record_bool);
+
     // Fix the number of user settable options
     num_user_settable_options_ = static_cast<HighsInt>(records.size());
 

thirdparty/solvers/highs/mip/HighsCutGeneration.h

@@ -73,6 +73,19 @@ class HighsCutGeneration {
   bool preprocessBaseInequality(bool& hasUnboundedInts, bool& hasGeneralInts,
                                 bool& hasContinuous);
 
+  void flipComplementation(HighsInt index);
+
+  void removeComplementation();
+
+  void updateViolationAndNorm(HighsInt index, double aj, double& violation,
+                              double& norm) const;
+
+  bool tryGenerateCut(std::vector<HighsInt>& inds, std::vector<double>& vals,
+                      bool hasUnboundedInts, bool hasGeneralInts,
+                      bool hasContinuous, double minEfficacy,
+                      bool onlyInitialCMIRScale = false,
+                      bool allowRejectCut = true, bool lpSol = true);
+
  public:
   HighsCutGeneration(const HighsLpRelaxation& lpRelaxation,
                      HighsCutPool& cutpool);

thirdparty/solvers/highs/presolve/HPresolve.h

@@ -315,10 +315,16 @@ class HPresolve {
 
   Result singletonCol(HighsPostsolveStack& postsolve_stack, HighsInt col);
 
+  void substituteFreeCol(HighsPostsolveStack& postsolve_stack, HighsInt row,
+                         HighsInt col, bool relaxRowDualBounds = false);
+
   Result rowPresolve(HighsPostsolveStack& postsolve_stack, HighsInt row);
 
   Result colPresolve(HighsPostsolveStack& postsolve_stack, HighsInt col);
 
+  Result detectDominatedCol(HighsPostsolveStack& postsolve_stack, HighsInt col,
+                            bool handleSingletonRows = true);
+
   Result initialRowAndColPresolve(HighsPostsolveStack& postsolve_stack);
 
   HighsModelStatus run(HighsPostsolveStack& postsolve_stack);
@@ -356,6 +362,11 @@ class HPresolve {
 
   Result detectParallelRowsAndCols(HighsPostsolveStack& postsolve_stack);
 
+  template <typename RowStorageFormat>
+  Result equalityRowAddition(HighsPostsolveStack& postsolve_stack,
+                             HighsInt stayrow, HighsInt removerow, double scale,
+                             const HighsMatrixSlice<RowStorageFormat>& vector);
+
   Result sparsify(HighsPostsolveStack& postsolve_stack);
 
   void setRelaxedImpliedBounds();

thirdparty/solvers/highs/simplex/HApp.h

@@ -112,6 +112,9 @@ inline HighsStatus solveLpSimplex(HighsLpSolverObject& solver_object) {
   // return
   resetModelStatusAndHighsInfo(solver_object);
 
+  // Initialise the simplex stats
+  ekk_instance.initialiseSimplexStats();
+
   // Assumes that the LP has a positive number of rows, since
   // unconstrained LPs should be solved in solveLp
   bool positive_num_row = solver_object.lp_.num_row_ > 0;

thirdparty/solvers/highs/simplex/HEkk.h

@@ -156,6 +156,12 @@ class HEkk {
                            const vector<double>& rowLower,
                            const vector<double>& rowUpper);
 
+  const HighsSimplexStats& getSimplexStats() const { return simplex_stats_; }
+  void initialiseSimplexStats() { simplex_stats_.initialise(iteration_count_); }
+  void reportSimplexStats(FILE* file, const std::string message = "") const {
+    simplex_stats_.report(file, message);
+  }
+
   // Make this private later
   void chooseSimplexStrategyThreads(const HighsOptions& options,
                                     HighsSimplexInfo& info);
@@ -255,6 +261,8 @@ class HEkk {
   std::vector<HighsSimplexBadBasisChangeRecord> bad_basis_change_;
   std::vector<double> primal_phase1_dual_;
 
+  HighsSimplexStats simplex_stats_;
+
  private:
   bool isUnconstrainedLp();
   void initialiseForSolve();

thirdparty/solvers/highs/simplex/HighsSimplexAnalysis.h

@@ -251,6 +251,7 @@ class HighsSimplexAnalysis {
   void reportFactorTimer();
   void updateInvertFormData(const HFactor& factor);
   void reportInvertFormData();
+  HighsInt numInvert() { return num_invert; }
 
   // Control methods to be moved to HEkkControl
   void dualSteepestEdgeWeightError(const double computed_edge_weight,