casadi 3.6.7__cp310-none-macosx_11_0_arm64.whl → 3.7.1__cp310-none-macosx_11_0_arm64.whl

casadi/include/highs/lp_data/HConst.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                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -21,12 +18,13 @@
 #include "util/HighsInt.h"
 
 const std::string kHighsCopyrightStatement =
-    "Copyright (c) 2024 HiGHS under MIT licence terms";
+    "Copyright (c) 2025 HiGHS under MIT licence terms";
 
 const size_t kHighsSize_tInf = std::numeric_limits<size_t>::max();
 const HighsInt kHighsIInf = std::numeric_limits<HighsInt>::max();
 const HighsInt kHighsIInf32 = std::numeric_limits<int>::max();
 const double kHighsInf = std::numeric_limits<double>::infinity();
+const double kHighsUndefined = kHighsInf;
 const double kHighsTiny = 1e-14;
 const double kHighsMacheps = std::ldexp(1, -52);
 const double kHighsZero = 1e-50;
@@ -85,11 +83,14 @@ enum HighsAnalysisLevel {
   kHighsAnalysisLevelSolverTime = 8,
   kHighsAnalysisLevelNlaData = 16,
   kHighsAnalysisLevelNlaTime = 32,
+  kHighsAnalysisLevelMipData = 64,
+  kHighsAnalysisLevelMipTime = 128,
   kHighsAnalysisLevelMin = kHighsAnalysisLevelNone,
   kHighsAnalysisLevelMax =
       kHighsAnalysisLevelModelData + kHighsAnalysisLevelSolverSummaryData +
       kHighsAnalysisLevelSolverRuntimeData + kHighsAnalysisLevelSolverTime +
-      kHighsAnalysisLevelNlaData + kHighsAnalysisLevelNlaTime
+      kHighsAnalysisLevelNlaData + kHighsAnalysisLevelNlaTime +
+      kHighsAnalysisLevelMipData + kHighsAnalysisLevelMipTime
 };
 
 enum class HighsVarType : uint8_t {
@@ -224,7 +225,8 @@ enum HighsCallbackType : int {
   kCallbackMipInterrupt,              // 6
   kCallbackMipGetCutPool,             // 7
   kCallbackMipDefineLazyConstraints,  // 8
-  kCallbackMax = kCallbackMipDefineLazyConstraints,
+  kCallbackMipUserSolution,           // 9
+  kCallbackMax = kCallbackMipUserSolution,
   kNumCallbackType
 };
 
@@ -264,6 +266,15 @@ enum PresolveRuleType : int {
   kPresolveRuleCount,
 };
 
+enum IisStrategy {
+  kIisStrategyMin = 0,
+  kIisStrategyFromLpRowPriority = kIisStrategyMin,  // 0
+  kIisStrategyFromLpColPriority,                    // 1
+  //  kIisStrategyFromRayRowPriority,                     // 2
+  //  kIisStrategyFromRayColPriority,                     // 3
+  kIisStrategyMax = kIisStrategyFromLpColPriority
+};
+
 // Default and max allowed power-of-two matrix scale factor
 const HighsInt kDefaultAllowedMatrixPow2Scale = 20;
 const HighsInt kMaxAllowedMatrixPow2Scale = 30;
@@ -278,6 +289,10 @@ const HighsInt kHighsIllegalInfeasibilityCount = -1;
 const double kHighsIllegalErrorValue = kHighsInf;
 const HighsInt kHighsIllegalErrorIndex = -1;
 
+// Illegal values for complementarity violations used to indicate that true
+// values aren't known
+const double kHighsIllegalComplementarityViolation = kHighsInf;
+
 // Maximum upper bound on semi-variables
 const double kMaxSemiVariableUpper = 1e5;
 

casadi/include/highs/lp_data/HStruct.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                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -33,6 +30,7 @@ struct HighsSolution {
   std::vector<double> col_dual;
   std::vector<double> row_value;
   std::vector<double> row_dual;
+  bool hasUndefined() const;
   void invalidate();
   void clear();
 };
@@ -52,22 +50,36 @@ struct RefactorInfo {
   void clear();
 };
 
+// Unused, but retained since there is a const reference to this in a
+// deprecated method
 struct HotStart {
   bool valid = false;
   RefactorInfo refactor_info;
   std::vector<int8_t> nonbasicMove;
-  void clear();
 };
 
 struct HighsBasis {
+  // Logical flags for a HiGHS basis:
+  //
+  // valid: has been factored by HiGHS
+  //
+  // alien: a basis that's been set externally, so cannot be assumed
+  // to even have the right number of basic and nonbasic variables
+  //
+  // useful: a basis that may be useful
+  //
+  // Need useful since, by default, a basis is alien but not useful
   bool valid = false;
   bool alien = true;
+  bool useful = false;
   bool was_alien = true;
   HighsInt debug_id = -1;
   HighsInt debug_update_count = -1;
   std::string debug_origin_name = "None";
   std::vector<HighsBasisStatus> col_status;
   std::vector<HighsBasisStatus> row_status;
+  void print(std::string message = "") const;
+  void printScalars(std::string message = "") const;
   void invalidate();
   void clear();
 };
@@ -143,4 +155,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_ */

casadi/include/highs/lp_data/HighsAnalysis.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/lp_data/HighsCallback.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                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -19,6 +16,16 @@
 #include "lp_data/HStruct.h"
 #include "lp_data/HighsCallbackStruct.h"
 
+enum userMipSolutionCallbackOrigin {
+  kUserMipSolutionCallbackOriginAfterSetup = 0,
+  kUserMipSolutionCallbackOriginBeforeDive,
+  kUserMipSolutionCallbackOriginEvaluateRootNode0,
+  kUserMipSolutionCallbackOriginEvaluateRootNode1,
+  kUserMipSolutionCallbackOriginEvaluateRootNode2,
+  kUserMipSolutionCallbackOriginEvaluateRootNode3,
+  kUserMipSolutionCallbackOriginEvaluateRootNode4
+};
+
 using HighsCallbackFunctionType =
     std::function<void(int, const std::string&, const HighsCallbackDataOut*,
                        HighsCallbackDataIn*, void*)>;

casadi/include/highs/lp_data/HighsCallbackStruct.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                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -32,6 +29,7 @@ typedef struct {
   HighsInt pdlp_iteration_count;
   double objective_function_value;
   int64_t mip_node_count;
+  int64_t mip_total_lp_iterations;
   double mip_primal_bound;
   double mip_dual_bound;
   double mip_gap;
@@ -44,10 +42,12 @@ typedef struct {
   double* cutpool_value;
   double* cutpool_lower;
   double* cutpool_upper;
+  HighsInt user_solution_callback_origin;
 } HighsCallbackDataOut;
 
 typedef struct {
   int user_interrupt;
+  double* user_solution;
 } HighsCallbackDataIn;
 
 // Additional callback handling

casadi/include/highs/lp_data/HighsDebug.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/lp_data/HighsIis.h

@@ -0,0 +1,62 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file lp_data/HighsIis.h
+ * @brief Class-independent utilities for HiGHS
+ */
+#ifndef LP_DATA_HIGHSIIS_H_
+#define LP_DATA_HIGHSIIS_H_
+
+#include "lp_data/HighsLp.h"
+
+const bool kIisDevReport = false;
+
+enum IisBoundStatus {
+  kIisBoundStatusDropped = -1,
+  kIisBoundStatusNull,   // 0
+  kIisBoundStatusFree,   // 1
+  kIisBoundStatusLower,  // 2
+  kIisBoundStatusUpper,  // 3
+  kIisBoundStatusBoxed   // 4
+};
+
+struct HighsIisInfo {
+  double simplex_time = 0;
+  HighsInt simplex_iterations = 0;
+};
+
+class HighsIis {
+ public:
+  HighsIis() {}
+
+  void invalidate();
+  std::string iisBoundStatusToString(HighsInt bound_status) const;
+  void report(const std::string message, const HighsLp& lp) const;
+  void addCol(const HighsInt col, const HighsInt status = kIisBoundStatusNull);
+  void addRow(const HighsInt row, const HighsInt status = kIisBoundStatusNull);
+  void removeCol(const HighsInt col);
+  void removeRow(const HighsInt row);
+  HighsStatus getData(const HighsLp& lp, const HighsOptions& options,
+                      const HighsBasis& basis,
+                      const std::vector<HighsInt>& infeasible_row);
+
+  HighsStatus compute(const HighsLp& lp, const HighsOptions& options,
+                      const HighsBasis* basis = nullptr);
+
+  bool trivial(const HighsLp& lp, const HighsOptions& options);
+
+  // Data members
+  bool valid_ = false;
+  HighsInt strategy_ = kIisStrategyMin;
+  std::vector<HighsInt> col_index_;
+  std::vector<HighsInt> row_index_;
+  std::vector<HighsInt> col_bound_;
+  std::vector<HighsInt> row_bound_;
+  std::vector<HighsIisInfo> info_;
+};
+
+#endif  // LP_DATA_HIGHSIIS_H_

casadi/include/highs/lp_data/HighsInfo.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                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -87,46 +84,6 @@ class InfoRecordDouble : public InfoRecord {
   virtual ~InfoRecordDouble() {}
 };
 
-InfoStatus getInfoIndex(const HighsLogOptions& report_log_options,
-                        const std::string& name,
-                        const std::vector<InfoRecord*>& info_records,
-                        HighsInt& index);
-
-InfoStatus checkInfo(const HighsLogOptions& report_log_options,
-                     const std::vector<InfoRecord*>& info_records);
-InfoStatus checkInfo(const InfoRecordInt& info);
-InfoStatus checkInfo(const InfoRecordDouble& info);
-
-InfoStatus getLocalInfoValue(const HighsLogOptions& report_log_options,
-                             const std::string& name, const bool valid,
-                             const std::vector<InfoRecord*>& info_records,
-                             int64_t& value);
-InfoStatus getLocalInfoValue(const HighsLogOptions& report_log_options,
-                             const std::string& name, const bool valid,
-                             const std::vector<InfoRecord*>& info_records,
-                             HighsInt& value);
-InfoStatus getLocalInfoValue(const HighsLogOptions& report_log_options,
-                             const std::string& name, const bool valid,
-                             const std::vector<InfoRecord*>& info_records,
-                             double& value);
-
-InfoStatus getLocalInfoType(const HighsLogOptions& report_log_options,
-                            const std::string& name,
-                            const std::vector<InfoRecord*>& info_records,
-                            HighsInfoType& type);
-
-HighsStatus writeInfoToFile(
-    FILE* file, const bool valid, const std::vector<InfoRecord*>& info_records,
-    const HighsFileType file_type = HighsFileType::kOther);
-void reportInfo(FILE* file, const std::vector<InfoRecord*>& info_records,
-                const HighsFileType file_type = HighsFileType::kOther);
-void reportInfo(FILE* file, const InfoRecordInt64& info,
-                const HighsFileType file_type = HighsFileType::kOther);
-void reportInfo(FILE* file, const InfoRecordInt& info,
-                const HighsFileType file_type = HighsFileType::kOther);
-void reportInfo(FILE* file, const InfoRecordDouble& info,
-                const HighsFileType file_type = HighsFileType::kOther);
-
 // For now, but later change so HiGHS properties are string based so that new
 // info (for debug and testing too) can be added easily. The info below
 // are just what has been used to parse info from argv.
@@ -155,6 +112,7 @@ struct HighsInfoStruct {
   double sum_dual_infeasibilities;
   double max_complementarity_violation;
   double sum_complementarity_violations;
+  double primal_dual_integral;
 };
 
 class HighsInfo : public HighsInfoStruct {
@@ -313,10 +271,59 @@ class HighsInfo : public HighsInfoStruct {
         "sum_complementarity_violations", "Sum of complementarity violations",
         advanced, &sum_complementarity_violations, 0);
     records.push_back(record_double);
+
+    record_double =
+        new InfoRecordDouble("primal_dual_integral", "Primal-dual integral",
+                             advanced, &primal_dual_integral, 0);
+    records.push_back(record_double);
   }
 
  public:
   std::vector<InfoRecord*> records;
 };
 
+HighsStatus writeInfoToFile(
+    FILE* file, const bool valid, const HighsInfo& info,
+    const HighsFileType file_type = HighsFileType::kFull);
+
+InfoStatus getInfoIndex(const HighsLogOptions& report_log_options,
+                        const std::string& name,
+                        const std::vector<InfoRecord*>& info_records,
+                        HighsInt& index);
+
+InfoStatus checkInfo(const HighsLogOptions& report_log_options,
+                     const std::vector<InfoRecord*>& info_records);
+InfoStatus checkInfo(const InfoRecordInt& info);
+InfoStatus checkInfo(const InfoRecordDouble& info);
+
+InfoStatus getLocalInfoValue(const HighsLogOptions& report_log_options,
+                             const std::string& name, const bool valid,
+                             const std::vector<InfoRecord*>& info_records,
+                             int64_t& value);
+InfoStatus getLocalInfoValue(const HighsLogOptions& report_log_options,
+                             const std::string& name, const bool valid,
+                             const std::vector<InfoRecord*>& info_records,
+                             HighsInt& value);
+InfoStatus getLocalInfoValue(const HighsLogOptions& report_log_options,
+                             const std::string& name, const bool valid,
+                             const std::vector<InfoRecord*>& info_records,
+                             double& value);
+
+InfoStatus getLocalInfoType(const HighsLogOptions& report_log_options,
+                            const std::string& name,
+                            const std::vector<InfoRecord*>& info_records,
+                            HighsInfoType& type);
+
+HighsStatus writeInfoToFile(
+    FILE* file, const bool valid, const std::vector<InfoRecord*>& info_records,
+    const HighsFileType file_type = HighsFileType::kFull);
+void reportInfo(FILE* file, const std::vector<InfoRecord*>& info_records,
+                const HighsFileType file_type = HighsFileType::kFull);
+void reportInfo(FILE* file, const InfoRecordInt64& info,
+                const HighsFileType file_type = HighsFileType::kFull);
+void reportInfo(FILE* file, const InfoRecordInt& info,
+                const HighsFileType file_type = HighsFileType::kFull);
+void reportInfo(FILE* file, const InfoRecordDouble& info,
+                const HighsFileType file_type = HighsFileType::kFull);
+
 #endif

casadi/include/highs/lp_data/HighsInfoDebug.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/lp_data/HighsLp.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                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -61,7 +58,9 @@ class HighsLp {
 
   bool operator==(const HighsLp& lp) const;
   bool equalButForNames(const HighsLp& lp) const;
+  bool equalButForScalingAndNames(const HighsLp& lp) const;
   bool equalNames(const HighsLp& lp) const;
+  bool equalScaling(const HighsLp& lp) const;
   bool isMip() const;
   bool hasSemiVariables() const;
   bool hasInfiniteCost(const double infinite_cost) const;

casadi/include/highs/lp_data/HighsLpSolverObject.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/lp_data/HighsLpUtils.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                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -201,7 +198,7 @@ void getLpMatrixCoefficient(const HighsLp& lp, const HighsInt row,
 void analyseLp(const HighsLogOptions& log_options, const HighsLp& lp);
 
 HighsStatus readSolutionFile(const std::string filename,
-                             const HighsOptions& options, const HighsLp& lp,
+                             const HighsOptions& options, HighsLp& lp,
                              HighsBasis& basis, HighsSolution& solution,
                              const HighsInt style);
 
@@ -216,7 +213,9 @@ bool readSolutionFileKeywordLineOk(std::string& keyword,
                                    std::ifstream& in_file);
 bool readSolutionFileHashKeywordIntLineOk(std::string& keyword, HighsInt& value,
                                           std::ifstream& in_file);
-bool readSolutionFileIdDoubleLineOk(double& value, std::ifstream& in_file);
+bool readSolutionFileIdIgnoreLineOk(std::string& id, std::ifstream& in_file);
+bool readSolutionFileIdDoubleLineOk(std::string& id, double& value,
+                                    std::ifstream& in_file);
 bool readSolutionFileIdDoubleIntLineOk(double& value, HighsInt& index,
                                        std::ifstream& in_file);
 
@@ -225,7 +224,8 @@ void assessColPrimalSolution(const HighsOptions& options, const double primal,
                              const HighsVarType type, double& col_infeasibility,
                              double& integer_infeasibility);
 
-HighsStatus assessLpPrimalSolution(const HighsOptions& options,
+HighsStatus assessLpPrimalSolution(const std::string message,
+                                   const HighsOptions& options,
                                    const HighsLp& lp,
                                    const HighsSolution& solution, bool& valid,
                                    bool& integral, bool& feasible);
@@ -263,4 +263,36 @@ HighsLp withoutSemiVariables(const HighsLp& lp, HighsSolution& solution,
 
 void removeRowsOfCountOne(const HighsLogOptions& log_options, HighsLp& lp);
 
+// Get subvectors from data structure of data0, data1, data2 and
+// matrix, where the storage of the matrix is compatible with the
+// vectors to be extracted from it
+//
+// Data to be extracted is given by sub_* being nullpointer
+//
+// * cost, lower and upper bounds for columns, and column-wise LP constraint
+// matrix
+//
+// * lower and upper bounds for rows, and row-wise LP constraint
+// * matrix. "cost" is nullptr, and so must be sub_vector_data0
+//
+void getSubVectors(const HighsIndexCollection& index_collection,
+                   const HighsInt data_dim, const double* data0,
+                   const double* data1, const double* data2,
+                   const HighsSparseMatrix& matrix, HighsInt& num_sub_vector,
+                   double* sub_vector_data0, double* sub_vector_data1,
+                   double* sub_vector_data2, HighsInt& sub_matrix_num_nz,
+                   HighsInt* sub_matrix_start, HighsInt* sub_matrix_index,
+                   double* sub_matrix_value);
+
+void getSubVectorsTranspose(const HighsIndexCollection& index_collection,
+                            const HighsInt data_dim, const double* data0,
+                            const double* data1, const double* data2,
+                            const HighsSparseMatrix& matrix,
+                            HighsInt& num_sub_vector, double* sub_vector_data0,
+                            double* sub_vector_data1, double* sub_vector_data2,
+                            HighsInt& sub_matrix_num_nz,
+                            HighsInt* sub_matrix_start,
+                            HighsInt* sub_matrix_index,
+                            double* sub_matrix_value);
+
 #endif  // LP_DATA_HIGHSLPUTILS_H_

casadi/include/highs/lp_data/HighsModelUtils.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                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -31,29 +28,33 @@ bool hasNamesWithSpaces(const HighsLogOptions& log_options,
                         const HighsInt num_name,
                         const std::vector<std::string>& names);
 void writeModelBoundSolution(
-    FILE* file, const bool columns, const HighsInt dim,
-    const std::vector<double>& lower, const std::vector<double>& upper,
-    const std::vector<std::string>& names, const bool have_primal,
-    const std::vector<double>& primal, const bool have_dual,
-    const std::vector<double>& dual, const bool have_basis,
-    const std::vector<HighsBasisStatus>& status,
+    FILE* file, const HighsLogOptions& log_options, const bool columns,
+    const HighsInt dim, const std::vector<double>& lower,
+    const std::vector<double>& upper, const std::vector<std::string>& names,
+    const bool have_primal, const std::vector<double>& primal,
+    const bool have_dual, const std::vector<double>& dual,
+    const bool have_basis, const std::vector<HighsBasisStatus>& status,
     const HighsVarType* integrality = NULL);
 
-void writeModelObjective(FILE* file, const HighsModel& model,
+void writeModelObjective(FILE* file, const HighsLogOptions& log_options,
+                         const HighsModel& model,
                          const std::vector<double>& primal_solution);
 
-void writeLpObjective(FILE* file, const HighsLp& lp,
+void writeLpObjective(FILE* file, const HighsLogOptions& log_options,
+                      const HighsLp& lp,
                       const std::vector<double>& primal_solution);
 
-void writeObjectiveValue(FILE* file, const double objective_value);
+void writeObjectiveValue(FILE* file, const HighsLogOptions& log_options,
+                         const double objective_value);
 
-void writePrimalSolution(FILE* file, const HighsLp& lp,
+void writePrimalSolution(FILE* file, const HighsLogOptions& log_options,
+                         const HighsLp& lp,
                          const std::vector<double>& primal_solution,
                          const bool sparse = false);
 
-void writeModelSolution(FILE* file, const HighsModel& model,
-                        const HighsSolution& solution, const HighsInfo& info,
-                        const bool sparse = false);
+void writeModelSolution(FILE* file, const HighsLogOptions& log_options,
+                        const HighsModel& model, const HighsSolution& solution,
+                        const HighsInfo& info, const bool sparse = false);
 
 HighsInt maxNameLength(const HighsInt num_name,
                        const std::vector<std::string>& names);
@@ -68,7 +69,8 @@ void writeSolutionFile(FILE* file, const HighsOptions& options,
                        const HighsModelStatus model_status,
                        const HighsInt style);
 
-void writeGlpsolCostRow(FILE* file, const bool raw, const bool is_mip,
+void writeGlpsolCostRow(FILE* file, const HighsLogOptions& log_options,
+                        const bool raw, const bool is_mip,
                         const HighsInt row_id, const std::string objective_name,
                         const double objective_function_value);
 
@@ -78,7 +80,8 @@ void writeGlpsolSolution(FILE* file, const HighsOptions& options,
                          const HighsModelStatus model_status,
                          const HighsInfo& info, const bool raw);
 
-void writeOldRawSolution(FILE* file, const HighsLp& lp, const HighsBasis& basis,
+void writeOldRawSolution(FILE* file, const HighsLogOptions& log_options,
+                         const HighsLp& lp, const HighsBasis& basis,
                          const HighsSolution& solution);
 
 HighsBasisStatus checkedVarHighsNonbasicStatus(