casadi 3.6.2__cp311-none-manylinux2014_x86_64.whl → 3.6.4__cp311-none-manylinux2014_x86_64.whl

casadi/include/highs/Highs.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 Highs.h
  * @brief The HiGHS class
@@ -18,6 +16,7 @@
 
 #include <sstream>
 
+#include "lp_data/HighsCallback.h"
 #include "lp_data/HighsLpUtils.h"
 #include "lp_data/HighsRanging.h"
 #include "lp_data/HighsSolutionDebug.h"
@@ -25,6 +24,21 @@
 #include "presolve/ICrash.h"
 #include "presolve/PresolveComponent.h"
 
+/**
+ * @brief Return the version
+ */
+const char* highsVersion();
+
+/**
+ * @brief Return detailed version information, githash and compilation
+ * date
+ */
+HighsInt highsVersionMajor();
+HighsInt highsVersionMinor();
+HighsInt highsVersionPatch();
+const char* highsGithash();
+const char* highsCompilationDate();
+
 /**
  * @brief Class to set parameters and run HiGHS
  */
@@ -32,13 +46,43 @@ class Highs {
  public:
   Highs();
   virtual ~Highs() {
-    FILE* log_file_stream = options_.log_options.log_file_stream;
-    if (log_file_stream != nullptr) {
-      assert(log_file_stream != stdout);
-      fclose(log_file_stream);
+    FILE* log_stream = options_.log_options.log_stream;
+    if (log_stream != nullptr) {
+      assert(log_stream != stdout);
+      fclose(log_stream);
     }
   }
 
+  /**
+   * @brief Return the version as a string
+   */
+  std::string version() const { return highsVersion(); }
+
+  /**
+   * @brief Return major version
+   */
+  HighsInt versionMajor() const { return highsVersionMajor(); }
+
+  /**
+   * @brief Return minor version
+   */
+  HighsInt versionMinor() const { return highsVersionMinor(); }
+
+  /**
+   * @brief Return patch version
+   */
+  HighsInt versionPatch() const { return highsVersionPatch(); }
+
+  /**
+   * @brief Return githash
+   */
+  std::string githash() const { return highsGithash(); }
+
+  /**
+   * @brief Return compilation date
+   */
+  std::string compilationDate() const { return highsCompilationDate(); }
+
   /**
    * @brief Reset the options and then call clearModel()
    */
@@ -111,6 +155,15 @@ 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 a column name to the incumbent model
+   */
+  HighsStatus passColName(const HighsInt col, const std::string& name);
+
+  /**
+   * @brief Pass a row name to the incumbent model
+   */
+  HighsStatus passRowName(const HighsInt row, const std::string& name);
 
   /**
    * @brief Read in a model
@@ -133,7 +186,12 @@ class Highs {
   HighsStatus run();
 
   /**
-   * @brief Postsolve the incumbent model
+   * @brief Postsolve the incumbent model using a solution
+   */
+  HighsStatus postsolve(const HighsSolution& solution);
+
+  /**
+   * @brief Postsolve the incumbent model using a solution and basis
    */
   HighsStatus postsolve(const HighsSolution& solution, const HighsBasis& basis);
 
@@ -150,10 +208,12 @@ class Highs {
                            const HighsInt style = kSolutionStyleRaw);
 
   /**
-   * @brief Check the feasibility of the current solution. Of value
-   * after calling Highs::readSolution
+   * @brief Assess the validity, integrality and feasibility of the
+   * current primal solution. Of value after calling
+   * Highs::readSolution
    */
-  HighsStatus checkSolutionFeasibility() const;
+  HighsStatus assessPrimalSolution(bool& valid, bool& integral,
+                                   bool& feasible) const;
 
   /**
    * Methods for HiGHS option input/output
@@ -199,21 +259,34 @@ class Highs {
   /**
    * @brief Gets an option value as bool/HighsInt/double/string and, for
    * bool/int/double, only if it's of the correct type.
+   *
+   * NB Deprecate in v2.0, in order to replace with more general
+   * get*OptionValues
    */
-  HighsStatus getOptionValue(const std::string& option, bool& value) const;
+  HighsStatus getOptionValue(const std::string& option, bool& value) const {
+    return this->getBoolOptionValues(option, &value);
+  }
 
-  HighsStatus getOptionValue(const std::string& option, HighsInt& value) const;
+  HighsStatus getOptionValue(const std::string& option, HighsInt& value) const {
+    return this->getIntOptionValues(option, &value);
+  }
 
-  HighsStatus getOptionValue(const std::string& option, double& value) const;
+  HighsStatus getOptionValue(const std::string& option, double& value) const {
+    return this->getDoubleOptionValues(option, &value);
+  }
 
   HighsStatus getOptionValue(const std::string& option,
-                             std::string& value) const;
+                             std::string& value) const {
+    return this->getStringOptionValues(option, &value);
+  }
 
   /**
    * @brief Get the type expected by an option
    */
   HighsStatus getOptionType(const std::string& option,
-                            HighsOptionType& type) const;
+                            HighsOptionType& type) const {
+    return this->getOptionType(option, &type);
+  }
 
   /**
    * @brief Reset the options to the default values
@@ -228,6 +301,56 @@ class Highs {
   HighsStatus writeOptions(const std::string& filename,  //!< The filename
                            const bool report_only_deviations = false) const;
 
+  /**
+   * @brief Returns the number of user-settable options
+   */
+  HighsInt getNumOptions() const {
+    return this->options_.num_user_settable_options_;
+  }
+
+  /**
+   * @brief Get the number of user-settable options
+   */
+  HighsStatus getOptionName(const HighsInt index, std::string* name) const;
+
+  /**
+   * @brief Get the type of an option
+   */
+  HighsStatus getOptionType(const std::string& option,
+                            HighsOptionType* type) const;
+
+  /**
+   * @brief Get the current and default values of a bool option
+   */
+  HighsStatus getBoolOptionValues(const std::string& option,
+                                  bool* current_value = nullptr,
+                                  bool* default_value = nullptr) const;
+
+  /**
+   * @brief Get the current, min, max and default values of an int option
+   */
+  HighsStatus getIntOptionValues(const std::string& option,
+                                 HighsInt* current_value = nullptr,
+                                 HighsInt* min_value = nullptr,
+                                 HighsInt* max_value = nullptr,
+                                 HighsInt* default_value = nullptr) const;
+
+  /**
+   * @brief Get the current, min, max and default values of a double option
+   */
+  HighsStatus getDoubleOptionValues(const std::string& option,
+                                    double* current_value = nullptr,
+                                    double* min_value = nullptr,
+                                    double* max_value = nullptr,
+                                    double* default_value = nullptr) const;
+
+  /**
+   * @brief Get the current and default values of a string option
+   */
+  HighsStatus getStringOptionValues(const std::string& option,
+                                    std::string* current_value = nullptr,
+                                    std::string* default_value = nullptr) const;
+
   /**
    * @brief Get a const reference to the internal info values
    * type.
@@ -247,12 +370,14 @@ class Highs {
 
   HighsStatus getInfoValue(const std::string& info, double& value) const;
 
+  HighsStatus getInfoType(const std::string& info, HighsInfoType& type) const;
+
   /**
    * @brief Write info values to a file, with the extension ".html"
    * producing HTML, otherwise using the standard format used to read
    * options from a file.
    */
-  HighsStatus writeInfo(const std::string& filename) const;
+  HighsStatus writeInfo(const std::string& filename = "") const;
 
   /**
    * @brief Get the value of infinity used by HiGHS
@@ -299,6 +424,21 @@ class Highs {
    */
   const HighsSolution& getSolution() const { return solution_; }
 
+  /**
+   * @brief Zero all clocks in the internal HighsTimer instance
+   */
+  void zeroAllClocks() { timer_.zeroAllClocks(); };
+
+  /**
+   * @brief Return a const reference to the internal HighsSolution instance
+   */
+  const std::vector<HighsObjectiveSolution>& getSavedMipSolutions() const {
+    return saved_objective_and_solution_;
+  }
+
+  /**
+   * @brief Return a const reference to the internal ICrash info instance
+   */
   const ICrashInfo& getICrashInfo() const { return icrash_info_; };
 
   /**
@@ -338,10 +478,8 @@ class Highs {
                            double* primal_ray_value = nullptr);
 
   /**
-   * @brief Get the ranging information for the current LP, possibly
-   * returning it, as well as holding it internally
+   * @brief Get the ranging information for the current LP
    */
-  HighsStatus getRanging();
   HighsStatus getRanging(HighsRanging& ranging);
 
   /**
@@ -360,15 +498,6 @@ class Highs {
    */
   bool hasInvert() const;
 
-  /**
-   * @brief Gets the internal basic variable index array in the order
-   * corresponding to calls to getBasisInverseRow, getBasisInverseCol,
-   * getBasisSolve, getBasisTransposeSolve, getReducedRow and getReducedColumn.
-   * Entries are indices of columns if in [0,num_col), and entries in [num_col,
-   * num_col+num_row) are (num_col+row_index).
-   */
-  const HighsInt* getBasicVariablesArray() const;
-
   /**
    * @brief Gets the basic variables in the order corresponding to
    * calls to getBasisInverseRow, getBasisInverseCol, getBasisSolve,
@@ -378,15 +507,6 @@ class Highs {
    */
   HighsStatus getBasicVariables(HighsInt* basic_variables);
 
-  /**
-   * @brief Form a row of \f$B^{-1}\f$ for basis matrix \f$B\f$,
-   * returning the result in the given HVector buffer which is
-   * expected to be setup with dimension num_row. The buffers
-   * previous contents will be overwritten.
-   */
-  HighsStatus getBasisInverseRowSparse(const HighsInt row,
-                                       HVector& row_ep_buffer);
-
   /**
    * @brief Form a row of \f$B^{-1}\f$ for basis matrix \f$B\f$,
    * returning the indices of the nonzeros unless row_num_nz is
@@ -529,6 +649,22 @@ class Highs {
       double* value  //!<  Array of size num_nz with row values for the columns
   );
 
+  /**
+   * @brief Get a column name from the incumbent model
+   */
+  HighsStatus getColName(const HighsInt col, std::string& name) const;
+
+  /**
+   * @brief Get column index corresponding to name
+   */
+  HighsStatus getColByName(const std::string& name, HighsInt& col);
+
+  /**
+   * @brief Get a column integrality from the incumbent model
+   */
+  HighsStatus getColIntegrality(const HighsInt col,
+                                HighsVarType& integrality) const;
+
   /**
    * @brief Get multiple rows from the model given by an interval [from_row,
    * to_row]
@@ -583,6 +719,16 @@ class Highs {
       double* value  //!< Array of size num_nz with column values for the rows
   );
 
+  /**
+   * @brief Get a row name from the incumbent model
+   */
+  HighsStatus getRowName(const HighsInt row, std::string& name) const;
+
+  /**
+   * @brief Get row index corresponding to name
+   */
+  HighsStatus getRowByName(const std::string& name, HighsInt& row);
+
   /**
    * @brief Get a matrix coefficient
    */
@@ -591,12 +737,12 @@ class Highs {
   /**
    * @brief Write out the incumbent model to a file
    */
-  HighsStatus writeModel(const std::string& filename);
+  HighsStatus writeModel(const std::string& filename = "");
 
   /**
    * @brief Write out the internal HighsBasis instance to a file
    */
-  HighsStatus writeBasis(const std::string& filename);
+  HighsStatus writeBasis(const std::string& filename = "");
 
   /**
    * Methods for incumbent model modification
@@ -871,11 +1017,22 @@ class Highs {
   HighsStatus setSolution(const HighsSolution& solution);
 
   /**
-   * @brief Set the callback method and user data to use for logging
+   * @brief Set the callback method to use for HiGHS
    */
-  HighsStatus setLogCallback(void (*log_callback)(HighsLogType, const char*,
-                                                  void*),
-                             void* log_callback_data = nullptr);
+  HighsStatus setCallback(void (*user_callback)(const int, const char*,
+                                                const HighsCallbackDataOut*,
+                                                HighsCallbackDataIn*, void*),
+                          void* user_callback_data = nullptr);
+
+  /**
+   * @brief Start callback of given type
+   */
+  HighsStatus startCallback(const int callback_type);
+
+  /**
+   * @brief Stop callback of given type
+   */
+  HighsStatus stopCallback(const int callback_type);
 
   /**
    * @brief Use the HighsBasis passed to set the internal HighsBasis
@@ -904,6 +1061,8 @@ class Highs {
   /**
    * @brief Interpret common qualifiers to string values
    */
+  std::string presolveStatusToString(
+      const HighsPresolveStatus presolve_status) const;
   std::string modelStatusToString(const HighsModelStatus model_status) const;
   std::string solutionStatusToString(const HighsInt solution_status) const;
   std::string basisStatusToString(const HighsBasisStatus basis_status) const;
@@ -984,11 +1143,30 @@ class Highs {
                : nullptr;
   }
 
-#ifdef OSI_FOUND
-  friend class OsiHiGHSSolverInterface;
-#endif
+  /**
+   * @brief Gets the internal basic variable index array in the order
+   * corresponding to calls to getBasisInverseRow, getBasisInverseCol,
+   * getBasisSolve, getBasisTransposeSolve, getReducedRow and getReducedColumn.
+   * Entries are indices of columns if in [0,num_col), and entries in [num_col,
+   * num_col+num_row) are (num_col+row_index).
+   */
+  const HighsInt* getBasicVariablesArray() const;
+
+  /**
+   * @brief Form a row of \f$B^{-1}\f$ for basis matrix \f$B\f$,
+   * returning the result in the given HVector buffer which is
+   * expected to be setup with dimension num_row. The buffers
+   * previous contents will be overwritten.
+   */
+  HighsStatus getBasisInverseRowSparse(const HighsInt row,
+                                       HVector& row_ep_buffer);
+
   // Start of deprecated methods
 
+  HighsStatus setLogCallback(void (*user_log_callback)(HighsLogType,
+                                                       const char*, void*),
+                             void* user_log_callback_data = nullptr);
+
   HighsInt getNumCols() const {
     deprecationMessage("getNumCols", "getNumCol");
     return getNumCol();
@@ -1093,10 +1271,13 @@ class Highs {
   HighsModel presolved_model_;
   HighsTimer timer_;
 
+  HighsCallback callback_;
   HighsOptions options_;
   HighsInfo info_;
   HighsRanging ranging_;
 
+  std::vector<HighsObjectiveSolution> saved_objective_and_solution_;
+
   HighsPresolveStatus model_presolve_status_ =
       HighsPresolveStatus::kNotPresolved;
   HighsModelStatus model_status_ = HighsModelStatus::kNotset;
@@ -1120,7 +1301,7 @@ class Highs {
     this->model_.hessian_.exactResize();
   }
 
-  HighsStatus assessContinuousMipSolution();
+  HighsStatus assignContinuousAtDiscreteSolution();
 
   HighsStatus callSolveLp(HighsLp& lp, const string message);
   HighsStatus callSolveQp();
@@ -1129,11 +1310,12 @@ class Highs {
                                const HighsBasis& basis);
 
   PresolveComponent presolve_;
-  HighsPresolveStatus runPresolve(const bool force_presolve = false);
+  HighsPresolveStatus runPresolve(const bool force_lp_presolve,
+                                  const bool force_presolve = false);
   HighsPostsolveStatus runPostsolve();
 
   HighsStatus openWriteFile(const string filename, const string method_name,
-                            FILE*& file, bool& html) const;
+                            FILE*& file, HighsFileType& file_type) const;
 
   void reportModel();
   void newHighsBasis();
@@ -1182,6 +1364,8 @@ class Highs {
   // Invalidates ekk_instance_
   void invalidateEkk();
 
+  HighsStatus returnFromWriteSolution(FILE* file,
+                                      const HighsStatus return_status);
   HighsStatus returnFromRun(const HighsStatus return_status);
   HighsStatus returnFromHighs(const HighsStatus return_status);
   void reportSolvedLpQpStats();
@@ -1259,12 +1443,17 @@ class Highs {
 
   HighsStatus getPrimalRayInterface(bool& has_primal_ray,
                                     double* primal_ray_value);
+  HighsStatus getRangingInterface();
   bool aFormatOk(const HighsInt num_nz, const HighsInt format);
   bool qFormatOk(const HighsInt num_nz, const HighsInt format);
   void clearZeroHessian();
   HighsStatus checkOptimality(const std::string& solver_type,
                               HighsStatus return_status);
   HighsStatus invertRequirementError(std::string method_name);
+  HighsStatus lpInvertRequirementError(std::string method_name);
+
+  HighsStatus handleInfCost();
+  void restoreInfCost(HighsStatus& return_status);
 };
 
 #endif

casadi/include/highs/filereaderlp/builder.hpp

@@ -1,26 +1,25 @@
 #ifndef __READERLP_BUILDER_HPP__
 #define __READERLP_BUILDER_HPP__
 
-#include <unordered_map>
 #include <memory>
 #include <string>
+#include <unordered_map>
 
 #include "model.hpp"
 
-struct Builder { 
-   std::unordered_map<std::string, std::shared_ptr<Variable>> variables;
+struct Builder {
+  std::unordered_map<std::string, std::shared_ptr<Variable>> variables;
 
-   Model model;
+  Model model;
 
-   std::shared_ptr<Variable> getvarbyname(const std::string& name) {
-      auto it = variables.find(name);
-      if (it != variables.end())
-         return it->second;
-      auto newvar = std::shared_ptr<Variable>(new Variable(name));
-      variables.insert(std::make_pair(name, newvar));
-      model.variables.push_back(newvar);
-      return newvar;
-   }
+  std::shared_ptr<Variable> getvarbyname(const std::string& name) {
+    auto it = variables.find(name);
+    if (it != variables.end()) return it->second;
+    auto newvar = std::shared_ptr<Variable>(new Variable(name));
+    variables.insert(std::make_pair(name, newvar));
+    model.variables.push_back(newvar);
+    return newvar;
+  }
 };
 
 #endif

casadi/include/highs/filereaderlp/model.hpp

@@ -7,65 +7,62 @@
 #include <vector>
 
 enum class VariableType {
-   CONTINUOUS,
-   BINARY,
-   GENERAL,
-   SEMICONTINUOUS,
-   SEMIINTEGER
+  CONTINUOUS,
+  BINARY,
+  GENERAL,
+  SEMICONTINUOUS,
+  SEMIINTEGER
 };
 
-enum class ObjectiveSense {
-   MIN,
-   MAX
-};
+enum class ObjectiveSense { MIN, MAX };
 
 struct Variable {
-   VariableType type = VariableType::CONTINUOUS;
-   double lowerbound = 0.0;
-   double upperbound = std::numeric_limits<double>::infinity();
-   std::string name;
+  VariableType type = VariableType::CONTINUOUS;
+  double lowerbound = 0.0;
+  double upperbound = std::numeric_limits<double>::infinity();
+  std::string name;
 
-   Variable(std::string n="") : name(n) {};
+  Variable(std::string n = "") : name(n){};
 };
 
 struct LinTerm {
-   std::shared_ptr<Variable> var;
-   double coef = 1.0;
+  std::shared_ptr<Variable> var;
+  double coef = 1.0;
 };
 
 struct QuadTerm {
-   std::shared_ptr<Variable> var1;
-   std::shared_ptr<Variable> var2;
-   double coef = 1.0;
+  std::shared_ptr<Variable> var1;
+  std::shared_ptr<Variable> var2;
+  double coef = 1.0;
 };
 
 struct Expression {
-   std::vector<std::shared_ptr<LinTerm>> linterms;
-   std::vector<std::shared_ptr<QuadTerm>> quadterms; 
-   double offset = 0.0;
-   std::string name = "";
+  std::vector<std::shared_ptr<LinTerm>> linterms;
+  std::vector<std::shared_ptr<QuadTerm>> quadterms;
+  double offset = 0.0;
+  std::string name = "";
 };
 
 struct Constraint {
-   double lowerbound = -std::numeric_limits<double>::infinity();
-   double upperbound = std::numeric_limits<double>::infinity();
-   std::shared_ptr<Expression> expr;
+  double lowerbound = -std::numeric_limits<double>::infinity();
+  double upperbound = std::numeric_limits<double>::infinity();
+  std::shared_ptr<Expression> expr;
 
-   Constraint() : expr(std::shared_ptr<Expression>(new Expression)) {};
+  Constraint() : expr(std::shared_ptr<Expression>(new Expression)){};
 };
 
 struct SOS {
-   std::string name = "";
-   short type = 0;   // 1 or 2
-   std::vector<std::pair<std::shared_ptr<Variable>, double>> entries;
+  std::string name = "";
+  short type = 0;  // 1 or 2
+  std::vector<std::pair<std::shared_ptr<Variable>, double>> entries;
 };
 
 struct Model {
-   std::shared_ptr<Expression> objective;
-   ObjectiveSense sense;
-   std::vector<std::shared_ptr<Constraint>> constraints;
-   std::vector<std::shared_ptr<Variable>> variables;
-   std::vector<std::shared_ptr<SOS>> soss;
+  std::shared_ptr<Expression> objective;
+  ObjectiveSense sense;
+  std::vector<std::shared_ptr<Constraint>> constraints;
+  std::vector<std::shared_ptr<Variable>> variables;
+  std::vector<std::shared_ptr<SOS>> soss;
 };
 
 #endif