casadi 3.6.3__cp311-none-manylinux2014_i686.whl → 3.6.4__cp311-none-manylinux2014_i686.whl

casadi/include/highs/lp_data/HighsInfo.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file lp_data/HighsInfo.h
  * @brief
@@ -89,38 +87,45 @@ class InfoRecordDouble : public InfoRecord {
   virtual ~InfoRecordDouble() {}
 };
 
-InfoStatus getInfoIndex(const HighsOptions& options, const std::string& name,
+InfoStatus getInfoIndex(const HighsLogOptions& report_log_options,
+                        const std::string& name,
                         const std::vector<InfoRecord*>& info_records,
                         HighsInt& index);
 
-InfoStatus checkInfo(const HighsOptions& options,
+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 HighsOptions& options,
+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 HighsOptions& options,
+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 HighsOptions& options,
+InfoStatus getLocalInfoValue(const HighsLogOptions& report_log_options,
                              const std::string& name, const bool valid,
                              const std::vector<InfoRecord*>& info_records,
                              double& value);
 
-HighsStatus writeInfoToFile(FILE* file, const bool valid,
+InfoStatus getLocalInfoType(const HighsLogOptions& report_log_options,
+                            const std::string& name,
                             const std::vector<InfoRecord*>& info_records,
-                            const bool html = false);
+                            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 bool html = false);
+                const HighsFileType file_type = HighsFileType::kOther);
 void reportInfo(FILE* file, const InfoRecordInt64& info,
-                const bool html = false);
-void reportInfo(FILE* file, const InfoRecordInt& info, const bool html = false);
+                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 bool html = false);
+                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
@@ -132,8 +137,8 @@ struct HighsInfoStruct {
   int64_t mip_node_count;
   HighsInt simplex_iteration_count;
   HighsInt ipm_iteration_count;
-  HighsInt qp_iteration_count;
   HighsInt crossover_iteration_count;
+  HighsInt qp_iteration_count;
   HighsInt primal_solution_status;
   HighsInt dual_solution_status;
   HighsInt basis_validity;
@@ -194,8 +199,7 @@ class HighsInfo : public HighsInfoStruct {
     InfoRecordInt64* record_int64;
     InfoRecordInt* record_int;
     InfoRecordDouble* record_double;
-    bool advanced;
-    advanced = false;
+    const bool advanced = false;  // Not used
 
     record_int = new InfoRecordInt("simplex_iteration_count",
                                    "Iteration count for simplex solver",
@@ -207,11 +211,6 @@ class HighsInfo : public HighsInfoStruct {
                                    &ipm_iteration_count, 0);
     records.push_back(record_int);
 
-    record_int =
-        new InfoRecordInt("qp_iteration_count", "Iteration count for QP solver",
-                          advanced, &qp_iteration_count, 0);
-    records.push_back(record_int);
-
     record_int = new InfoRecordInt("crossover_iteration_count",
                                    "Iteration count for crossover", advanced,
                                    &crossover_iteration_count, 0);

casadi/include/highs/lp_data/HighsInfoDebug.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file lp_data/HighsInfoDebug.h
  * @brief

casadi/include/highs/lp_data/HighsLp.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file lp_data/HighsLp.h
  * @brief
@@ -17,7 +15,6 @@
 #define LP_DATA_HIGHS_LP_H_
 
 #include <string>
-#include <vector>
 
 #include "lp_data/HStruct.h"
 #include "util/HighsSparseMatrix.h"
@@ -43,22 +40,31 @@ class HighsLp {
   std::string model_name_;
   std::string objective_name_;
 
+  HighsInt new_col_name_ix_ = 0;
+  HighsInt new_row_name_ix_ = 0;
   std::vector<std::string> col_names_;
   std::vector<std::string> row_names_;
 
   std::vector<HighsVarType> integrality_;
 
+  HighsNameHash col_hash_;
+  HighsNameHash row_hash_;
+
   HighsScale scale_;
   bool is_scaled_;
   bool is_moved_;
   HighsInt cost_row_location_;
+  bool has_infinite_cost_;
   HighsLpMods mods_;
 
-  bool operator==(const HighsLp& lp);
+  bool operator==(const HighsLp& lp) const;
   bool equalButForNames(const HighsLp& lp) const;
+  bool equalNames(const HighsLp& lp) const;
   bool isMip() const;
   bool hasSemiVariables() const;
+  bool hasInfiniteCost(const double infinite_cost) const;
   double objectiveValue(const std::vector<double>& solution) const;
+  HighsCDouble objectiveCDoubleValue(const std::vector<double>& solution) const;
   void setMatrixDimensions();
   void setFormat(const MatrixFormat format);
   void ensureColwise() { this->a_matrix_.ensureColwise(); };
@@ -70,6 +76,8 @@ class HighsLp {
   void unapplyScale();
   void moveBackLpAndUnapplyScaling(HighsLp& lp);
   void exactResize();
+  void addColNames(const std::string name, const HighsInt num_new_col = 1);
+  void addRowNames(const std::string name, const HighsInt num_new_row = 1);
   void unapplyMods();
   void clear();
 };

casadi/include/highs/lp_data/HighsLpSolverObject.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file simplex/HighsLpSolverObject.h
  * @brief Collection of class instances required to solve an LP
@@ -24,12 +22,14 @@ class HighsLpSolverObject {
  public:
   HighsLpSolverObject(HighsLp& lp, HighsBasis& basis, HighsSolution& solution,
                       HighsInfo& highs_info, HEkk& ekk_instance,
-                      HighsOptions& options, HighsTimer& timer)
+                      HighsCallback& callback, HighsOptions& options,
+                      HighsTimer& timer)
       : lp_(lp),
         basis_(basis),
         solution_(solution),
         highs_info_(highs_info),
         ekk_instance_(ekk_instance),
+        callback_(callback),
         options_(options),
         timer_(timer) {}
 
@@ -38,6 +38,7 @@ class HighsLpSolverObject {
   HighsSolution& solution_;
   HighsInfo& highs_info_;
   HEkk& ekk_instance_;
+  HighsCallback& callback_;
   HighsOptions& options_;
   HighsTimer& timer_;
 

casadi/include/highs/lp_data/HighsLpUtils.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file lp_data/HighsLpUtils.h
  * @brief Class-independent utilities for HiGHS
@@ -47,13 +45,15 @@ bool lpDimensionsOk(std::string message, const HighsLp& lp,
 
 HighsStatus assessCosts(const HighsOptions& options, const HighsInt ml_col_os,
                         const HighsIndexCollection& index_collection,
-                        vector<double>& cost, const double infinite_cost);
+                        vector<double>& cost, bool& has_infinite_cost,
+                        const double infinite_cost);
 
 HighsStatus assessBounds(const HighsOptions& options, const char* type,
                          const HighsInt ml_ix_os,
                          const HighsIndexCollection& index_collection,
                          vector<double>& lower, vector<double>& upper,
-                         const double infinite_bound);
+                         const double infinite_bound,
+                         const HighsVarType* integrality = nullptr);
 
 HighsStatus cleanBounds(const HighsOptions& options, HighsLp& lp);
 
@@ -63,7 +63,8 @@ bool activeModifiedUpperBounds(const HighsOptions& options, const HighsLp& lp,
                                const std::vector<double> col_value);
 
 bool considerScaling(const HighsOptions& options, HighsLp& lp);
-void scaleLp(const HighsOptions& options, HighsLp& lp);
+void scaleLp(const HighsOptions& options, HighsLp& lp,
+             const bool force_scaling = false);
 bool equilibrationScaleMatrix(const HighsOptions& options, HighsLp& lp,
                               const HighsInt use_scale_strategy);
 bool maxValueScaleMatrix(const HighsOptions& options, HighsLp& lp,
@@ -106,7 +107,8 @@ void changeLpIntegrality(HighsLp& lp,
                          const vector<HighsVarType>& new_integrality);
 
 void changeLpCosts(HighsLp& lp, const HighsIndexCollection& index_collection,
-                   const vector<double>& new_col_cost);
+                   const vector<double>& new_col_cost,
+                   const double infinite_cost);
 
 void changeLpColBounds(HighsLp& lp,
                        const HighsIndexCollection& index_collection,
@@ -214,16 +216,25 @@ bool readSolutionFileKeywordLineOk(std::string& keyword,
 bool readSolutionFileHashKeywordIntLineOk(std::string& keyword, HighsInt& value,
                                           std::ifstream& in_file);
 bool readSolutionFileIdDoubleLineOk(double& value, std::ifstream& in_file);
+bool readSolutionFileIdDoubleIntLineOk(double& value, HighsInt& index,
+                                       std::ifstream& in_file);
+
+void assessColPrimalSolution(const HighsOptions& options, const double primal,
+                             const double lower, const double upper,
+                             const HighsVarType type, double& col_infeasibility,
+                             double& integer_infeasibility);
 
-HighsStatus checkLpSolutionFeasibility(const HighsOptions& options,
-                                       const HighsLp& lp,
-                                       const HighsSolution& solution);
+HighsStatus assessLpPrimalSolution(const HighsOptions& options,
+                                   const HighsLp& lp,
+                                   const HighsSolution& solution, bool& valid,
+                                   bool& integral, bool& feasible);
 
 HighsStatus calculateRowValues(const HighsLp& lp,
                                const std::vector<double>& col_value,
                                std::vector<double>& row_value);
 HighsStatus calculateRowValues(const HighsLp& lp, HighsSolution& solution);
-HighsStatus calculateRowValuesQuad(const HighsLp& lp, HighsSolution& solution);
+HighsStatus calculateRowValuesQuad(const HighsLp& lp, HighsSolution& solution,
+                                   const HighsInt report_row = -1);
 HighsStatus calculateColDuals(const HighsLp& lp, HighsSolution& solution);
 
 bool isBoundInfeasible(const HighsLogOptions& log_options, const HighsLp& lp);

casadi/include/highs/lp_data/HighsModelUtils.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file lp_data/HighsModelUtils.h
  * @brief Class-independent utilities for HiGHS
@@ -16,10 +14,10 @@
 #ifndef LP_DATA_HIGHSMODELUTILS_H_
 #define LP_DATA_HIGHSMODELUTILS_H_
 
-// #include "Highs.h"
-// #include "lp_data/HighsStatus.h"
 #include "lp_data/HighsInfo.h"
 #include "model/HighsModel.h"
+// #include "Highs.h"
+// #include "lp_data/HighsStatus.h"
 // #include "lp_data/HStruct.h"
 // #include "lp_data/HighsInfo.h"
 // #include "lp_data/HighsLp.h"
@@ -40,8 +38,22 @@ void writeModelBoundSolution(
     const std::vector<double>& dual, const bool have_basis,
     const std::vector<HighsBasisStatus>& status,
     const HighsVarType* integrality = NULL);
-void writeModelSolution(FILE* file, const HighsLp& lp,
-                        const HighsSolution& solution, const HighsInfo& info);
+
+void writeModelObjective(FILE* file, const HighsModel& model,
+                         const std::vector<double>& primal_solution);
+
+void writeLpObjective(FILE* file, const HighsLp& lp,
+                      const std::vector<double>& primal_solution);
+
+void writeObjectiveValue(FILE* file, const double objective_value);
+
+void writePrimalSolution(FILE* file, 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);
 
 HighsInt maxNameLength(const HighsInt num_name,
                        const std::vector<std::string>& names);
@@ -92,4 +104,6 @@ std::string typeToString(const HighsVarType type);
 std::string findModelObjectiveName(const HighsLp* lp,
                                    const HighsHessian* hessian = nullptr);
 
+// bool repeatedNames(const std::vector<std::string> name);
+
 #endif