casadi 3.6.7__cp39-none-win_amd64.whl → 3.7.0__cp39-none-win_amd64.whl

casadi/include/highs/simplex/HApp.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
-/*    Leona Gottwald and Michael Feldmeier                               */
-/*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -70,6 +67,10 @@ inline HighsStatus returnFromSolveLpSimplex(HighsLpSolverObject& solver_object,
                  "Error in basis matrix inverse after solving the LP\n");
     return_status = HighsStatus::kError;
   }
+  if (solver_object.model_status_ == HighsModelStatus::kOptimal) {
+    solver_object.highs_info_.max_complementarity_violation = 0;
+    solver_object.highs_info_.sum_complementarity_violations = 0;
+  }
   return return_status;
 }
 
@@ -108,6 +109,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;
@@ -128,10 +132,23 @@ inline HighsStatus solveLpSimplex(HighsLpSolverObject& solver_object) {
   // Consider scaling the LP - either with any existing scaling, or by
   // considering computing scaling factors if there are none - and
   // then move to EKK
-  const bool new_scaling = considerScaling(options, incumbent_lp);
-  // If new scaling is performed, the hot start information is
-  // no longer valid
-  if (new_scaling) ekk_instance.clearHotStart();
+  considerScaling(options, incumbent_lp);
+  //
+  if (!status.has_basis && !basis.valid && basis.useful) {
+    // There is no simplex basis, but there is a useful HiGHS basis
+    // that is not validated
+    assert(basis.col_status.size() ==
+           static_cast<size_t>(incumbent_lp.num_col_));
+    assert(basis.row_status.size() ==
+           static_cast<size_t>(incumbent_lp.num_row_));
+    HighsStatus return_status = formSimplexLpBasisAndFactor(solver_object);
+    if (return_status != HighsStatus::kOk)
+      return returnFromSolveLpSimplex(solver_object, HighsStatus::kError);
+    // formSimplexLpBasisAndFactor may introduce variables with
+    // HighsBasisStatus::kNonbasic, so refine it
+    refineBasis(incumbent_lp, solution, basis);
+    basis.valid = true;
+  }
   // Move the LP to EKK, updating other EKK pointers and any simplex
   // NLA pointers, since they may have moved if the LP has been
   // modified
@@ -250,12 +267,27 @@ inline HighsStatus solveLpSimplex(HighsLpSolverObject& solver_object) {
           scaled_model_status == HighsModelStatus::kOptimal &&
           (num_unscaled_primal_infeasibilities ||
            num_unscaled_dual_infeasibilities);
-      if (scaled_optimality_but_unscaled_infeasibilities)
+      // Determine whether the unscaled solution has primal
+      // infeasibilities after the scaled LP has been solved to the
+      // objective target
+      const bool scaled_objective_target_but_unscaled_primal_infeasibilities =
+          scaled_model_status == HighsModelStatus::kObjectiveTarget &&
+          highs_info.num_primal_infeasibilities > 0;
+      // Determine whether the unscaled solution has dual
+      // infeasibilities after the scaled LP has been solved to the
+      // objective bound
+      const bool scaled_objective_bound_but_unscaled_dual_infeasibilities =
+          scaled_model_status == HighsModelStatus::kObjectiveBound &&
+          highs_info.num_dual_infeasibilities > 0;
+      if (scaled_optimality_but_unscaled_infeasibilities ||
+          scaled_objective_target_but_unscaled_primal_infeasibilities ||
+          scaled_objective_bound_but_unscaled_dual_infeasibilities)
         highsLogDev(options.log_options, HighsLogType::kInfo,
-                    "Have num/max/sum primal (%" HIGHSINT_FORMAT
-                    "/%g/%g) and dual (%" HIGHSINT_FORMAT
+                    "After unscaling with status %s, have num/max/sum primal "
+                    "(%" HIGHSINT_FORMAT "/%g/%g) and dual (%" HIGHSINT_FORMAT
                     "/%g/%g) "
                     "unscaled infeasibilities\n",
+                    utilModelStatusToString(scaled_model_status).c_str(),
                     highs_info.num_primal_infeasibilities,
                     highs_info.max_primal_infeasibility,
                     highs_info.sum_primal_infeasibilities,
@@ -270,8 +302,8 @@ inline HighsStatus solveLpSimplex(HighsLpSolverObject& solver_object) {
            scaled_model_status == HighsModelStatus::kInfeasible ||
            scaled_model_status == HighsModelStatus::kUnboundedOrInfeasible ||
            scaled_model_status == HighsModelStatus::kUnbounded ||
-           scaled_model_status == HighsModelStatus::kObjectiveBound ||
-           scaled_model_status == HighsModelStatus::kObjectiveTarget ||
+           scaled_objective_bound_but_unscaled_dual_infeasibilities ||
+           scaled_objective_target_but_unscaled_primal_infeasibilities ||
            scaled_model_status == HighsModelStatus::kUnknown);
       // Handle the case when refinement will not take place
       if (!refine_solution) {
@@ -303,11 +335,14 @@ inline HighsStatus solveLpSimplex(HighsLpSolverObject& solver_object) {
     // LP, see whether the proof still holds for the unscaled LP. If
     // it does, then there's no need to solve the unscaled LP
     solve_unscaled_lp = true;
-    // ToDo: ekk_instance.status_.has_dual_ray should now be true if
-    // scaled_model_status == HighsModelStatus::kInfeasible since this
-    // model status depends on the infeasibility proof being true
+    // ToDo: ekk_instance.dual_ray_record_.index != kNoRayIndex should
+    // now be true if scaled_model_status ==
+    // HighsModelStatus::kInfeasible since this model status depends
+    // on the infeasibility proof being true
+    if (scaled_model_status == HighsModelStatus::kInfeasible)
+      assert(ekk_instance.dual_ray_record_.index != kNoRayIndex);
     if (scaled_model_status == HighsModelStatus::kInfeasible &&
-        ekk_instance.status_.has_dual_ray) {
+        ekk_instance.dual_ray_record_.index != kNoRayIndex) {
       ekk_instance.setNlaPointersForLpAndScale(ekk_lp);
       if (ekk_instance.proofOfPrimalInfeasibility()) solve_unscaled_lp = false;
     }
@@ -318,21 +353,31 @@ inline HighsStatus solveLpSimplex(HighsLpSolverObject& solver_object) {
           options.dual_simplex_cost_perturbation_multiplier;
       HighsInt simplex_dual_edge_weight_strategy =
           ekk_info.dual_edge_weight_strategy;
+      // #1865 exposed that this should not be
+      // HighsModelStatus::kObjectiveBound, but
+      // HighsModelStatus::kObjectiveTarget, since if the latter is
+      // the model status for the scaled LP, any primal
+      // infeasibilities should be small, but must be cleaned up
+      // before (hopefully) a few phase 2 primal simplex iterations
+      // are required to attain the target for the unscaled LP
+      //
+      // In #1865, phase 2 primal simplex was forced with large primal
+      // infeasibilities
       if (num_unscaled_primal_infeasibilities == 0 ||
-          scaled_model_status == HighsModelStatus::kObjectiveBound) {
-        // Only dual infeasibilities, or primal infeasibilities do not
-        // matter due to solution status, so use primal simplex phase
-        // 2
+          scaled_model_status == HighsModelStatus::kObjectiveTarget) {
+        // Only dual infeasibilities, or objective target reached (in
+        // primal phase 2) - so primal infeasibilities should be small
+        // - so use primal simplex phase 2
         options.simplex_strategy = kSimplexStrategyPrimal;
-        if (scaled_model_status == HighsModelStatus::kObjectiveBound) {
-          highsLogDev(
-              options.log_options, HighsLogType::kInfo,
-              "solveLpSimplex: Calling primal simplex after "
-              "scaled_model_status == HighsModelStatus::kObjectiveBound: solve "
-              "= %d; tick = %d; iter = %d\n",
-              (int)ekk_instance.debug_solve_call_num_,
-              (int)ekk_instance.debug_initial_build_synthetic_tick_,
-              (int)ekk_instance.iteration_count_);
+        if (scaled_model_status == HighsModelStatus::kObjectiveTarget) {
+          highsLogDev(options.log_options, HighsLogType::kInfo,
+                      "solveLpSimplex: Calling primal simplex after "
+                      "scaled_model_status == "
+                      "HighsModelStatus::kObjectiveTarget: solve "
+                      "= %d; tick = %d; iter = %d\n",
+                      (int)ekk_instance.debug_solve_call_num_,
+                      (int)ekk_instance.debug_initial_build_synthetic_tick_,
+                      (int)ekk_instance.iteration_count_);
         }
       } else {
         // Using dual simplex, so force Devex if starting from an advanced
@@ -345,11 +390,21 @@ inline HighsStatus solveLpSimplex(HighsLpSolverObject& solver_object) {
       //
       // Solve the unscaled LP with scaled NLA
       //
-      // Force the simplex solver to start in phase 2 unless solving
-      // the LP directly as unscaled
+      // Force the simplex solver to start in phase 1 if solving the
+      // LP directly as unscaled, or using primal simplex to clean up
+      // small dual infeasibilities after the scaled LP yielded model
+      // status HighsModelStatus::kObjectiveTarget. Otherwise force
+      // the simplex solver to start in phase 2
       //
-      const bool force_phase2 = options.simplex_unscaled_solution_strategy !=
-                                kSimplexUnscaledSolutionStrategyDirect;
+      const bool force_phase1 =
+          (options.simplex_unscaled_solution_strategy ==
+           kSimplexUnscaledSolutionStrategyDirect) ||
+          (scaled_model_status == HighsModelStatus::kObjectiveTarget);
+      const bool force_phase2 =
+          (options.simplex_unscaled_solution_strategy !=
+           kSimplexUnscaledSolutionStrategyDirect) &&
+          (scaled_model_status != HighsModelStatus::kObjectiveTarget);
+      assert(force_phase2 == !force_phase1);
       return_status = ekk_instance.solve(force_phase2);
       solved_unscaled_lp = true;
       if (scaled_model_status != HighsModelStatus::kObjectiveBound &&
@@ -358,7 +413,6 @@ inline HighsStatus solveLpSimplex(HighsLpSolverObject& solver_object) {
         // for the first time in which case we again call solve with primal
         // simplex if not dual feasible
         const bool objective_bound_refinement =
-            ekk_instance.model_status_ == HighsModelStatus::kObjectiveBound &&
             ekk_info.num_dual_infeasibilities > 0;
         if (objective_bound_refinement) {
           options.simplex_strategy = kSimplexStrategyPrimal;

casadi/include/highs/simplex/HEkk.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
-/*    Leona Gottwald and Michael Feldmeier                               */
-/*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -76,6 +73,7 @@ class HEkk {
   void clearEkkDataStatus();
   void clearNlaStatus();
   void clearNlaInvertStatus();
+  void clearRayRecords();
 
   void invalidate();
   void invalidateBasisMatrix();
@@ -86,7 +84,6 @@ class HEkk {
   void setNlaPointersForLpAndScale(const HighsLp& lp);
   void setNlaPointersForTrans(const HighsLp& lp);
   void setNlaRefactorInfo();
-  void clearHotStart();
   void btran(HVector& rhs, const double expected_density);
   void ftran(HVector& rhs, const double expected_density);
 
@@ -105,10 +102,6 @@ class HEkk {
   HighsStatus setBasis();
   HighsStatus setBasis(const HighsBasis& highs_basis);
 
-  void freezeBasis(HighsInt& frozen_basis_id);
-  HighsStatus unfreezeBasis(const HighsInt frozen_basis_id);
-  HighsStatus frozenBasisAllDataClear();
-
   void putIterate();
   HighsStatus getIterate();
 
@@ -134,13 +127,18 @@ class HEkk {
   HighsBasis getHighsBasis(HighsLp& use_lp) const;
 
   const SimplexBasis& getSimplexBasis() { return basis_; }
+  double computeBasisCondition(const HighsLp& lp, const bool exact = false,
+                               const bool report = false) const;
+  double computeBasisCondition() const {
+    return computeBasisCondition(this->lp_, false, false);
+  }
 
   HighsStatus initialiseSimplexLpBasisAndFactor(
       const bool only_from_known_basis = false);
   void handleRankDeficiency();
   void initialisePartitionedRowwiseMatrix();
-  bool lpFactorRowCompatible();
-  bool lpFactorRowCompatible(HighsInt expectedNumRow);
+  bool lpFactorRowCompatible() const;
+  bool lpFactorRowCompatible(const HighsInt expectedNumRow) const;
 
   // Interface methods
   void appendColsToVectors(const HighsInt num_new_col,
@@ -151,6 +149,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);
@@ -187,6 +191,9 @@ class HEkk {
   HighsSparseMatrix ar_matrix_;
   HighsSparseMatrix scaled_a_matrix_;
   HSimplexNla simplex_nla_;
+
+  // Unused, but retained since there is a const reference to this in
+  // a deprecated method
   HotStart hot_start_;
 
   double cost_scale_;
@@ -208,6 +215,10 @@ class HEkk {
   vector<HighsInt> proof_index_;
   vector<double> proof_value_;
 
+  // Data to be retained after computing primal or dual ray
+  HighsRayRecord dual_ray_record_;
+  HighsRayRecord primal_ray_record_;
+
   // Data to be retained when dualizing
   HighsInt original_num_col_;
   HighsInt original_num_row_;
@@ -244,6 +255,9 @@ class HEkk {
   double debug_max_relative_dual_steepest_edge_weight_error;
 
   std::vector<HighsSimplexBadBasisChangeRecord> bad_basis_change_;
+  std::vector<double> primal_phase1_dual_;
+
+  HighsSimplexStats simplex_stats_;
 
  private:
   bool isUnconstrainedLp();
@@ -332,7 +346,6 @@ class HEkk {
   HighsStatus returnFromEkkSolve(const HighsStatus return_status);
   HighsStatus returnFromSolve(const HighsStatus return_status);
 
-  double computeBasisCondition();
   void initialiseAnalysis();
   std::string rebuildReason(const HighsInt rebuild_reason);
 

casadi/include/highs/simplex/HEkkDual.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
-/*    Leona Gottwald and Michael Feldmeier                               */
-/*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -388,6 +385,7 @@ class HEkkDual {
   HighsInt solver_num_row;
   HighsInt solver_num_col;
   HighsInt solver_num_tot;
+  double inv_solver_num_row;  // 1.0 / solver_num_row
 
   const HighsSparseMatrix* a_matrix;
   const HSimplexNla* simplex_nla;
@@ -485,7 +483,7 @@ class HEkkDual {
    * @brief Multiple minor iteration data
    */
   struct MFinish {
-    HighsInt move_in;
+    int8_t move_in;
     double shiftOut;
     std::vector<HighsInt> flipList;
 

casadi/include/highs/simplex/HEkkDualRHS.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
-/*    Leona Gottwald and Michael Feldmeier                               */
-/*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

casadi/include/highs/simplex/HEkkDualRow.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
-/*    Leona Gottwald and Michael Feldmeier                               */
-/*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

casadi/include/highs/simplex/HEkkPrimal.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
-/*    Leona Gottwald and Michael Feldmeier                               */
-/*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -104,8 +101,7 @@ class HEkkPrimal {
   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,
-                  const bool report = false);
+                  const double random_value, double& bound, double& shift);
   void savePrimalRay();
   HighsDebugStatus debugPrimalSimplex(const std::string message,
                                       const bool initialise = false);

casadi/include/highs/simplex/HSimplex.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
-/*    Leona Gottwald and Michael Feldmeier                               */
-/*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

casadi/include/highs/simplex/HSimplexDebug.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
-/*    Leona Gottwald and Michael Feldmeier                               */
-/*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

casadi/include/highs/simplex/HSimplexNla.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
-/*    Leona Gottwald and Michael Feldmeier                               */
-/*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -40,16 +37,6 @@ struct ProductFormUpdate {
   void ftran(HVector& rhs) const;
 };
 
-struct FrozenBasis {
-  bool valid_ = false;
-  HighsInt prev_;
-  HighsInt next_;
-  ProductFormUpdate update_;
-  SimplexBasis basis_;
-  std::vector<double> dual_edge_weight_;
-  void clear();
-};
-
 struct SimplexIterate {
   bool valid_ = false;
   SimplexBasis basis_;
@@ -85,17 +72,8 @@ class HSimplexNla {
   void ftranInScaledSpace(
       HVector& rhs, const double expected_density,
       HighsTimerClock* factor_timer_clock_pointer = NULL) const;
-  void frozenBtran(HVector& rhs) const;
-  void frozenFtran(HVector& rhs) const;
   void update(HVector* aq, HVector* ep, HighsInt* iRow, HighsInt* hint);
 
-  void frozenBasisClearAllData();
-  void frozenBasisClearAllUpdate();
-  bool frozenBasisAllDataClear();
-  bool frozenBasisIdValid(const HighsInt frozen_basis_id) const;
-  bool frozenBasisHasInvert(const HighsInt frozen_basis_id) const;
-  HighsInt freeze(const SimplexBasis& basis, const double col_aq_density);
-  void unfreeze(const HighsInt unfreeze_basis_id, SimplexBasis& basis);
   void putInvert();
   void getInvert();
 
@@ -167,10 +145,6 @@ class HSimplexNla {
   bool report_;
   double build_synthetic_tick_;
 
-  // Frozen basis data
-  HighsInt first_frozen_basis_id_ = kNoLink;
-  HighsInt last_frozen_basis_id_ = kNoLink;
-  vector<FrozenBasis> frozen_basis_;
   ProductFormUpdate update_;
 
   // Simplex iterate data

casadi/include/highs/simplex/HSimplexReport.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
-/*    Leona Gottwald and Michael Feldmeier                               */
-/*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

casadi/include/highs/simplex/HighsSimplexAnalysis.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
-/*    Leona Gottwald and Michael Feldmeier                               */
-/*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -23,11 +20,6 @@
 #include "lp_data/HighsOptions.h"
 #include "simplex/SimplexConst.h"
 #include "util/HFactor.h"
-#include "util/HVector.h"
-#include "util/HVectorBase.h"
-#include "util/HighsInt.h"
-#include "util/HighsTimer.h"
-#include "util/HighsUtils.h"
 
 enum TRAN_STAGE {
   TRAN_STAGE_FTRAN_LOWER = 0,
@@ -160,8 +152,10 @@ class HighsSimplexAnalysis {
         max_sum_average_log_extreme_dual_steepest_edge_weight_error(0.0),
         num_invert_report_since_last_header(-1),
         num_iteration_report_since_last_header(-1),
+        highs_run_time(0.0),
         last_user_log_time(-kHighsInf),
         delta_user_log_time(1e0),
+        timeless_log(false),
         average_concurrency(0.0),
         average_fraction_of_possible_minor_iterations_performed(0.0),
         sum_multi_chosen(0),
@@ -256,6 +250,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,
@@ -435,8 +430,10 @@ class HighsSimplexAnalysis {
 
   HighsInt num_invert_report_since_last_header;
   HighsInt num_iteration_report_since_last_header;
+  double highs_run_time;
   double last_user_log_time;
   double delta_user_log_time;
+  bool timeless_log;
 
   double average_concurrency;
   double average_fraction_of_possible_minor_iterations_performed;

casadi/include/highs/simplex/SimplexConst.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
-/*    Leona Gottwald and Michael Feldmeier                               */
-/*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -146,17 +143,17 @@ const HighsInt kDualMultiMinConcurrency = 1;  // 2;
 // Simplex nonbasicFlag status for columns and rows. Don't use enum
 // class since they are used as HighsInt to replace conditional
 // statements by multiplication
-const HighsInt kNonbasicFlagTrue = 1;   // Nonbasic
-const HighsInt kNonbasicFlagFalse = 0;  // Basic
-const HighsInt kIllegalFlagValue =
+const int8_t kNonbasicFlagTrue = 1;   // Nonbasic
+const int8_t kNonbasicFlagFalse = 0;  // Basic
+const int8_t kIllegalFlagValue =
     -99;  // Used to see whether valid flag value has been set
 
 // Simplex nonbasicMove status for columns and rows. Don't use enum
 // class since they are used in conditional statements
-const HighsInt kNonbasicMoveUp = 1;   // Free to move (only) up
-const HighsInt kNonbasicMoveDn = -1;  // Free to move (only) down
-const HighsInt kNonbasicMoveZe = 0;   // Fixed or free to move up and down
-const HighsInt kIllegalMoveValue =
+const int8_t kNonbasicMoveUp = 1;   // Free to move (only) up
+const int8_t kNonbasicMoveDn = -1;  // Free to move (only) down
+const int8_t kNonbasicMoveZe = 0;   // Fixed or free to move up and down
+const int8_t kIllegalMoveValue =
     -99;  // Used to see whether valid move value has been set
 
 // Threshold for accepting updated DSE weight
@@ -167,6 +164,9 @@ const double kMinDualSteepestEdgeWeight = 1e-4;
 const HighsInt kNoRowSought = -2;
 const HighsInt kNoRowChosen = -1;
 
+const HighsInt kNoRayIndex = -1;
+const HighsInt kNoRaySign = 0;
+
 // Switch to use code to check that, unless the basis supplied by the
 // MIP solver was alien, the simplex solver starts from dual
 // feasibility.
@@ -185,7 +185,6 @@ enum class LpAction {
   kDelRowsBasisOk,
   kScaledCol,
   kScaledRow,
-  kHotStart,
   kBacktracking
 };
 

casadi/include/highs/simplex/SimplexStruct.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
-/*    Leona Gottwald and Michael Feldmeier                               */
-/*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -57,9 +54,7 @@ struct HighsSimplexStatus {
   bool has_dual_objective_value =
       false;  // The dual objective function value is known
   bool has_primal_objective_value =
-      false;                    // The dual objective function value is known
-  bool has_dual_ray = false;    // A dual unbounded ray is known
-  bool has_primal_ray = false;  // A primal unbounded ray is known
+      false;  // The dual objective function value is known
 };
 
 struct HighsSimplexInfo {
@@ -137,12 +132,6 @@ struct HighsSimplexInfo {
   std::vector<double> backtracking_basis_workUpperShift_;
   std::vector<double> backtracking_basis_edge_weight_;
 
-  // Dual and primal ray vectors
-  HighsInt dual_ray_row_;
-  HighsInt dual_ray_sign_;
-  HighsInt primal_ray_col_;
-  HighsInt primal_ray_sign_;
-
   // Options from HighsOptions for the simplex solver
   HighsInt simplex_strategy;
   HighsInt dual_edge_weight_strategy;
@@ -261,4 +250,12 @@ struct HighsSimplexBadBasisChangeRecord {
   double save_value;
 };
 
+struct HighsRayRecord {
+  HighsInt index;
+  HighsInt sign;
+  std::vector<double> value;
+  HighsRayRecord getRayRecord() const;
+  void setRayRecord(const HighsRayRecord& from_record);
+  void clear();
+};
 #endif /* SIMPLEX_SIMPLEXSTRUCT_H_ */