casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/highs/lp_data/HighsRanging.h

@@ -0,0 +1,46 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    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                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file lp_data/HighsRanging.h
+ * @brief
+ */
+#ifndef LP_DATA_HIGHS_RANGING_H_
+#define LP_DATA_HIGHS_RANGING_H_
+
+#include <vector>
+
+#include "lp_data/HighsLpSolverObject.h"
+
+struct HighsRangingRecord {
+  std::vector<double> value_;
+  std::vector<double> objective_;
+  std::vector<HighsInt> in_var_;
+  std::vector<HighsInt> ou_var_;
+};
+
+struct HighsRanging {
+  bool valid = false;
+  HighsRangingRecord col_cost_up;
+  HighsRangingRecord col_cost_dn;
+  HighsRangingRecord col_bound_up;
+  HighsRangingRecord col_bound_dn;
+  HighsRangingRecord row_bound_up;
+  HighsRangingRecord row_bound_dn;
+  void invalidate();
+  void clear();
+};
+
+HighsStatus getRangingData(HighsRanging& ranging,
+                           HighsLpSolverObject& solver_object);
+void writeRangingFile(FILE* file, const HighsLp& lp,
+                      const double objective_function_value,
+                      const HighsBasis& basis, const HighsSolution& solution,
+                      const HighsRanging& ranging, const HighsInt style);
+#endif

casadi/include/highs/lp_data/HighsRuntimeOptions.h

@@ -0,0 +1,276 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    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                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#ifndef LP_DATA_HIGHSRUNTIMEOPTIONS_H_
+#define LP_DATA_HIGHSRUNTIMEOPTIONS_H_
+
+#include "cxxopts.hpp"
+#include "io/HighsIO.h"
+#include "io/LoadOptions.h"
+#include "util/stringutil.h"
+
+bool loadOptions(const HighsLogOptions& report_log_options, int argc,
+                 char** argv, HighsOptions& options, std::string& model_file,
+                 std::string& read_solution_file) {
+  try {
+    cxxopts::Options cxx_options(argv[0], "HiGHS options");
+    cxx_options.positional_help("[file]").show_positional_help();
+
+    cxx_options.add_options()
+        //
+        // Command line file specifications
+        //
+        // model file
+        (kModelFileString, "File of model to solve.",
+         cxxopts::value<std::vector<std::string>>())
+        // read_solution file
+        (kReadSolutionFileString, "File of solution to read.",
+         cxxopts::value<std::vector<std::string>>())
+        // options file
+        (kOptionsFileString, "File containing HiGHS options.",
+         cxxopts::value<std::vector<std::string>>())
+        //
+        // Command line option specifications
+        //
+        // presolve option
+        (kPresolveString,
+         "Presolve: \"choose\" by default - \"on\"/\"off\" are alternatives.",
+         cxxopts::value<std::string>())
+        // solver option
+        (kSolverString,
+         "Solver: \"choose\" by default - \"simplex\"/\"ipm\" are "
+         "alternatives.",
+         cxxopts::value<std::string>())
+        // parallel option
+        (kParallelString,
+         "Parallel solve: \"choose\" by default - \"on\"/\"off\" are "
+         "alternatives.",
+         cxxopts::value<std::string>())
+        // run_crossover option
+        (kRunCrossoverString,
+         "Run crossover: \"on\" by default - \"choose\"/\"off\" are "
+         "alternatives.",
+         cxxopts::value<std::string>())
+        // time_limit option
+        (kTimeLimitString, "Run time limit (seconds - double).",
+         cxxopts::value<double>())
+        // solution_file option
+        (kSolutionFileString, "File for writing out model solution.",
+         cxxopts::value<std::vector<std::string>>())
+        // write_model_file option
+        (kWriteModelFileString, "File for writing out model.",
+         cxxopts::value<std::vector<std::string>>())
+        // random_seed option
+        (kRandomSeedString, "Seed to initialize random number generation.",
+         cxxopts::value<HighsInt>())
+        // ranging option
+        (kRangingString, "Compute cost, bound, RHS and basic solution ranging.",
+         cxxopts::value<std::string>())
+        // version
+        (kVersionString, "Print version.")("h, help", "Print help.");
+
+    // Handle command line file specifications
+    //
+    // model file
+    cxx_options.parse_positional("model_file");
+
+    auto result = cxx_options.parse(argc, argv);
+
+    if (result.count("help")) {
+      std::cout << cxx_options.help({""}) << std::endl;
+      exit(0);
+    }
+    if (result.count("version")) {
+      std::cout << "HiGHS version " << HIGHS_VERSION_MAJOR << "."
+                << HIGHS_VERSION_MINOR << "." << HIGHS_VERSION_PATCH;
+      std::cout << " Githash " << HIGHS_GITHASH << ". ";
+      std::cout << kHighsCopyrightStatement << std::endl;
+      exit(0);
+    }
+    if (result.count(kModelFileString)) {
+      auto& v = result[kModelFileString].as<std::vector<std::string>>();
+      if (v.size() > 1) {
+        HighsInt nonEmpty = 0;
+        for (HighsInt i = 0; i < (HighsInt)v.size(); i++) {
+          std::string arg = v[i];
+          if (trim(arg).size() > 0) {
+            nonEmpty++;
+            model_file = arg;
+          }
+        }
+        if (nonEmpty > 1) {
+          std::cout << "Multiple files not implemented.\n";
+          return false;
+        }
+      } else {
+        model_file = v[0];
+      }
+    }
+    read_solution_file = "";
+    if (result.count(kReadSolutionFileString)) {
+      auto& v = result[kReadSolutionFileString].as<std::vector<std::string>>();
+      if (v.size() > 1) {
+        HighsInt nonEmpty = 0;
+        for (size_t i = 0; i < v.size(); i++) {
+          std::string arg = v[i];
+          if (trim(arg).size() > 0) {
+            nonEmpty++;
+            read_solution_file = arg;
+          }
+        }
+        if (nonEmpty > 1) {
+          std::cout << "Multiple files not implemented.\n";
+          return false;
+        }
+      } else {
+        read_solution_file = v[0];
+      }
+    }
+    // options file
+    if (result.count(kOptionsFileString)) {
+      auto& v = result[kOptionsFileString].as<std::vector<std::string>>();
+      if (v.size() > 1) {
+        std::cout << "Multiple options files not implemented.\n";
+        return false;
+      }
+      switch (loadOptionsFromFile(report_log_options, options, v[0])) {
+        case HighsLoadOptionsStatus::kError:
+          return false;
+        case HighsLoadOptionsStatus::kEmpty:
+          writeOptionsToFile(stdout, options.records);
+          return false;
+        default:
+          break;
+      }
+    }
+
+    // Handle command line option specifications
+    //
+    // presolve option
+    if (result.count(kPresolveString)) {
+      std::string value = result[kPresolveString].as<std::string>();
+      if (setLocalOptionValue(report_log_options, kPresolveString,
+                              options.log_options, options.records,
+                              value) != OptionStatus::kOk)
+        return false;
+    }
+
+    // solver option
+    if (result.count(kSolverString)) {
+      std::string value = result[kSolverString].as<std::string>();
+      if (setLocalOptionValue(report_log_options, kSolverString,
+                              options.log_options, options.records,
+                              value) != OptionStatus::kOk)
+        return false;
+    }
+
+    // parallel option
+    if (result.count(kParallelString)) {
+      std::string value = result[kParallelString].as<std::string>();
+      if (setLocalOptionValue(report_log_options, kParallelString,
+                              options.log_options, options.records,
+                              value) != OptionStatus::kOk)
+        return false;
+    }
+
+    // run_crossover option
+    if (result.count(kRunCrossoverString)) {
+      std::string value = result[kRunCrossoverString].as<std::string>();
+      if (setLocalOptionValue(report_log_options, kRunCrossoverString,
+                              options.log_options, options.records,
+                              value) != OptionStatus::kOk)
+        return false;
+    }
+
+    // time_limit option
+    if (result.count(kTimeLimitString)) {
+      double value = result[kTimeLimitString].as<double>();
+      if (setLocalOptionValue(report_log_options, kTimeLimitString,
+                              options.records, value) != OptionStatus::kOk)
+        return false;
+    }
+
+    // solution_file option
+    if (result.count(kSolutionFileString)) {
+      auto& v = result[kSolutionFileString].as<std::vector<std::string>>();
+      if (v.size() > 1) {
+        std::cout << "Multiple solution files not implemented.\n";
+        return false;
+      }
+      if (setLocalOptionValue(report_log_options, kSolutionFileString,
+                              options.log_options, options.records,
+                              v[0]) != OptionStatus::kOk ||
+          setLocalOptionValue(report_log_options, "write_solution_to_file",
+                              options.records, true) != OptionStatus::kOk)
+        return false;
+    }
+
+    // write_model_file option
+    if (result.count(kWriteModelFileString)) {
+      auto& v = result[kWriteModelFileString].as<std::vector<std::string>>();
+      if (v.size() > 1) {
+        std::cout << "Multiple write model files not implemented.\n";
+        return false;
+      }
+      if (setLocalOptionValue(report_log_options, kWriteModelFileString,
+                              options.log_options, options.records,
+                              v[0]) != OptionStatus::kOk ||
+          setLocalOptionValue(report_log_options, "write_model_to_file",
+                              options.records, true) != OptionStatus::kOk)
+        return false;
+    }
+
+    // random_seed option
+    if (result.count(kRandomSeedString)) {
+      HighsInt value = result[kRandomSeedString].as<HighsInt>();
+      if (setLocalOptionValue(report_log_options, kRandomSeedString,
+                              options.records, value) != OptionStatus::kOk)
+        return false;
+    }
+
+    // ranging option
+    if (result.count(kRangingString)) {
+      std::string value = result[kRangingString].as<std::string>();
+      if (setLocalOptionValue(report_log_options, kRangingString,
+                              options.log_options, options.records,
+                              value) != OptionStatus::kOk)
+        return false;
+    }
+
+  } catch (const cxxopts::OptionException& e) {
+    highsLogUser(report_log_options, HighsLogType::kError,
+                 "Error parsing options: %s\n", e.what());
+    return false;
+  }
+
+  const bool horrible_hack_for_windows_visual_studio = false;
+  if (horrible_hack_for_windows_visual_studio) {
+    // Until I know how to debug an executable using command line
+    // arguments in Visual Studio on Windows, this is necessary!
+    HighsInt random_seed = -3;
+    if (random_seed >= 0) {
+      if (setLocalOptionValue(report_log_options, kRandomSeedString,
+                              options.records,
+                              random_seed) != OptionStatus::kOk)
+        return false;
+    }
+    model_file = "ml.mps";
+  }
+
+  if (model_file.size() == 0) {
+    std::cout << "Please specify filename in .mps|.lp|.ems format.\n";
+    return false;
+  }
+
+  return true;
+}
+
+#endif

casadi/include/highs/lp_data/HighsSolution.h

@@ -0,0 +1,137 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    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                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file lp_data/HighsSolution.h
+ * @brief Class-independent utilities for HiGHS
+ */
+#ifndef LP_DATA_HIGHSSOLUTION_H_
+#define LP_DATA_HIGHSSOLUTION_H_
+
+#include <string>
+#include <vector>
+
+#include "io/HighsIO.h"
+#include "lp_data/HStruct.h"
+#include "lp_data/HighsInfo.h"
+#include "lp_data/HighsLpSolverObject.h"
+#include "lp_data/HighsStatus.h"
+#include "model/HighsModel.h"
+
+class HighsLp;
+struct IpxSolution;
+class HighsOptions;
+
+using std::string;
+
+struct HighsError {
+  double absolute_value;
+  HighsInt absolute_index;
+  double relative_value;
+  HighsInt relative_index;
+  void print(std::string message);
+  void reset();
+  void invalidate();
+};
+
+struct HighsPrimalDualErrors {
+  HighsInt num_nonzero_basic_duals;
+  HighsInt num_large_nonzero_basic_duals;
+  double max_nonzero_basic_dual;
+  double sum_nonzero_basic_duals;
+  HighsInt num_off_bound_nonbasic;
+  double max_off_bound_nonbasic;
+  double sum_off_bound_nonbasic;
+  HighsInt num_primal_residual;
+  double sum_primal_residual;
+  HighsInt num_dual_residual;
+  double sum_dual_residual;
+  HighsError max_primal_residual;
+  HighsError max_primal_infeasibility;
+  HighsError max_dual_residual;
+  HighsError max_dual_infeasibility;
+};
+
+void getKktFailures(const HighsOptions& options, const HighsModel& model,
+                    const HighsSolution& solution, const HighsBasis& basis,
+                    HighsInfo& highs_info);
+
+void getKktFailures(const HighsOptions& options, const HighsModel& model,
+                    const HighsSolution& solution, const HighsBasis& basis,
+                    HighsInfo& highs_info,
+                    HighsPrimalDualErrors& primal_dual_errors,
+                    const bool get_residuals = false);
+
+void getLpKktFailures(const HighsOptions& options, const HighsLp& lp,
+                      const HighsSolution& solution, const HighsBasis& basis,
+                      HighsInfo& highs_info);
+
+void getLpKktFailures(const HighsOptions& options, const HighsLp& lp,
+                      const HighsSolution& solution, const HighsBasis& basis,
+                      HighsInfo& highs_info,
+                      HighsPrimalDualErrors& primal_dual_errors,
+                      const bool get_residuals = false);
+
+void getKktFailures(const HighsOptions& options, const HighsLp& lp,
+                    const std::vector<double>& gradient,
+                    const HighsSolution& solution, const HighsBasis& basis,
+                    HighsInfo& highs_info,
+                    HighsPrimalDualErrors& primal_dual_errors,
+                    const bool get_residuals = false);
+
+bool getVariableKktFailures(const double primal_feasibility_tolerance,
+                            const double dual_feasibility_tolerance,
+                            const double lower, const double upper,
+                            const double value, const double dual,
+                            const HighsBasisStatus* status_pointer,
+                            const HighsVarType integrality,
+                            double& absolute_primal_infeasibility,
+                            double& relative_primal_infeasibility,
+                            double& dual_infeasibility, double& value_residual);
+
+double computeObjectiveValue(const HighsLp& lp, const HighsSolution& solution);
+
+void refineBasis(const HighsLp& lp, const HighsSolution& solution,
+                 HighsBasis& basis);
+
+HighsStatus ipxSolutionToHighsSolution(
+    const HighsOptions& options, const HighsLp& lp,
+    const std::vector<double>& rhs, const std::vector<char>& constraint_type,
+    const HighsInt ipx_num_col, const HighsInt ipx_num_row,
+    const std::vector<double>& ipx_x, const std::vector<double>& ipx_slack_vars,
+    const std::vector<double>& ipx_y, const std::vector<double>& ipx_zl,
+    const std::vector<double>& ipx_zu, const HighsModelStatus model_status,
+    HighsSolution& highs_solution);
+
+HighsStatus ipxBasicSolutionToHighsBasicSolution(
+    const HighsLogOptions& log_options, const HighsLp& lp,
+    const std::vector<double>& rhs, const std::vector<char>& constraint_type,
+    const IpxSolution& ipx_solution, HighsBasis& highs_basis,
+    HighsSolution& highs_solution);
+
+HighsStatus formSimplexLpBasisAndFactorReturn(
+    const HighsStatus return_status, HighsLpSolverObject& solver_object);
+HighsStatus formSimplexLpBasisAndFactor(
+    HighsLpSolverObject& solver_object,
+    const bool only_from_known_basis = false);
+
+void accommodateAlienBasis(HighsLpSolverObject& solver_object);
+
+void resetModelStatusAndHighsInfo(HighsLpSolverObject& solver_object);
+void resetModelStatusAndHighsInfo(HighsModelStatus& model_status,
+                                  HighsInfo& highs_info);
+bool isBasisConsistent(const HighsLp& lp, const HighsBasis& basis);
+
+bool isPrimalSolutionRightSize(const HighsLp& lp,
+                               const HighsSolution& solution);
+bool isDualSolutionRightSize(const HighsLp& lp, const HighsSolution& solution);
+bool isSolutionRightSize(const HighsLp& lp, const HighsSolution& solution);
+bool isBasisRightSize(const HighsLp& lp, const HighsBasis& basis);
+
+#endif  // LP_DATA_HIGHSSOLUTION_H_

casadi/include/highs/lp_data/HighsSolutionDebug.h

@@ -0,0 +1,90 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    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                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file lp_data/HighsSolutionDebug.h
+ * @brief
+ */
+#ifndef SIMPLEX_HIGHSSOLUTIONDEBUG_H_
+#define SIMPLEX_HIGHSSOLUTIONDEBUG_H_
+
+#include "lp_data/HighsInfo.h"
+#include "lp_data/HighsLp.h"
+#include "lp_data/HighsOptions.h"
+#include "lp_data/HighsSolution.h"
+
+HighsDebugStatus debugHighsLpSolution(const std::string message,
+                                      const HighsLpSolverObject& solver_object);
+
+HighsDebugStatus debugHighsSolution(const string message,
+                                    const HighsOptions& options,
+                                    const HighsModel& model,
+                                    const HighsSolution& solution,
+                                    const HighsBasis& basis);
+
+HighsDebugStatus debugHighsSolution(
+    const string message, const HighsOptions& options, const HighsModel& model,
+    const HighsSolution& solution, const HighsBasis& basis,
+    const HighsModelStatus model_status, const HighsInfo& info);
+
+HighsDebugStatus debugHighsSolution(
+    const std::string message, const HighsOptions& options, const HighsLp& lp,
+    const HighsHessian& hessian, const HighsSolution& solution,
+    const HighsBasis& basis, const HighsModelStatus model_status,
+    const HighsInfo& highs_info, const bool check_model_status_and_highs_info);
+
+void debugReportHighsSolution(const string message,
+                              const HighsLogOptions& log_options,
+                              const HighsInfo& highs_info,
+                              const HighsModelStatus model_status);
+
+HighsDebugStatus debugBasisRightSize(const HighsOptions& options,
+                                     const HighsLp& lp,
+                                     const HighsBasis& basis);
+
+HighsDebugStatus debugPrimalSolutionRightSize(const HighsOptions& options,
+                                              const HighsLp& lp,
+                                              const HighsSolution& solution);
+
+HighsDebugStatus debugDualSolutionRightSize(const HighsOptions& options,
+                                            const HighsLp& lp,
+                                            const HighsSolution& solution);
+
+HighsDebugStatus debugHighsBasisConsistent(const HighsOptions& options,
+                                           const HighsLp& lp,
+                                           const HighsBasis& basis);
+
+// Methods below are not called externally
+
+HighsDebugStatus debugAnalysePrimalDualErrors(
+    const HighsOptions& options, HighsPrimalDualErrors& primal_dual_errors);
+
+HighsDebugStatus debugCompareHighsInfo(const HighsOptions& options,
+                                       const HighsInfo& highs_info0,
+                                       const HighsInfo& highs_info1);
+HighsDebugStatus debugCompareHighsInfoObjective(const HighsOptions& options,
+                                                const HighsInfo& highs_info0,
+                                                const HighsInfo& highs_info1);
+HighsDebugStatus debugCompareHighsInfoStatus(const HighsOptions& options,
+                                             const HighsInfo& highs_info0,
+                                             const HighsInfo& highs_info1);
+HighsDebugStatus debugCompareHighsInfoInfeasibility(
+    const HighsOptions& options, const HighsInfo& highs_info0,
+    const HighsInfo& highs_info1);
+
+HighsDebugStatus debugCompareHighsInfoDouble(const string name,
+                                             const HighsOptions& options,
+                                             const double v0, const double v1);
+
+HighsDebugStatus debugCompareHighsInfoInteger(const string name,
+                                              const HighsOptions& options,
+                                              const HighsInt v0,
+                                              const HighsInt v1);
+
+#endif  // SIMPLEX_HIGHSSOLUTIONDEBUG_H_

casadi/include/highs/lp_data/HighsSolve.h

@@ -0,0 +1,26 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    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                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file lp_data/HighsSolve.h
+ * @brief Class-independent utilities for HiGHS
+ */
+#ifndef LP_DATA_HIGHSSOLVE_H_
+#define LP_DATA_HIGHSSOLVE_H_
+
+#include "lp_data/HighsModelUtils.h"
+HighsStatus solveLp(HighsLpSolverObject& solver_object, const string message);
+HighsStatus solveUnconstrainedLp(HighsLpSolverObject& solver_object);
+HighsStatus solveUnconstrainedLp(const HighsOptions& options, const HighsLp& lp,
+                                 HighsModelStatus& model_status,
+                                 HighsInfo& highs_info, HighsSolution& solution,
+                                 HighsBasis& basis);
+void assessExcessiveBoundCost(const HighsLogOptions log_options,
+                              const HighsModel& model);
+#endif  // LP_DATA_HIGHSSOLVE_H_

casadi/include/highs/lp_data/HighsStatus.h

@@ -0,0 +1,32 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    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                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#ifndef LP_DATA_HIGHS_STATUS_H_
+#define LP_DATA_HIGHS_STATUS_H_
+
+#include <string>
+
+#include "io/HighsIO.h"
+
+enum class HighsStatus { kError = -1, kOk = 0, kWarning = 1 };
+
+// Return a string representation of HighsStatus.
+std::string highsStatusToString(HighsStatus status);
+
+// Return the maximum of two HighsStatus and possibly report on
+// call_status not being HighsStatus::kOk
+HighsStatus interpretCallStatus(const HighsLogOptions log_options,
+                                const HighsStatus call_status,
+                                const HighsStatus from_return_status,
+                                const std::string& message = "");
+
+// Return the maximum of two HighsStatus
+HighsStatus worseStatus(HighsStatus status0, HighsStatus status1);
+#endif