lpsolver 0.1.0 → 0.2.0

data/ext/lpsolver-highs/build/include/highs/lp_data/HighsRanging.h

@@ -0,0 +1,43 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    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

data/ext/lpsolver-highs/build/include/highs/lp_data/HighsSolution.h

@@ -0,0 +1,179 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    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;
+
+// Collecting absolute and relative errors, and the corresponding
+// indices is required for Glpsol output
+struct HighsError {
+  double absolute_value;
+  HighsInt absolute_index;
+  double relative_value;
+  HighsInt relative_index;
+  void print(std::string message);
+  void reset();
+  void invalidate();
+};
+
+// These are values used for HighsSolutionDebug, or for Glpsol output,
+// so not worthy of being in HighsInfo
+struct HighsPrimalDualErrors {
+  HighsInt num_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 glpsol_num_primal_residual_errors;
+  HighsInt glpsol_num_dual_residual_errors;
+  HighsError glpsol_max_primal_residual;
+  HighsError glpsol_max_primal_infeasibility;
+  HighsError glpsol_max_dual_residual;
+  HighsError glpsol_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);
+
+// Inner getKktFailures
+void getKktFailures(const HighsOptions& options, const bool is_qp,
+                    const HighsLp& lp, const std::vector<double>& gradient,
+                    const HighsSolution& solution, HighsInfo& highs_info,
+                    const bool get_residuals = false);
+
+void getVariableKktFailures(const double primal_feasibility_tolerance,
+                            const double dual_feasibility_tolerance,
+                            const double lower, const double upper,
+                            const double value, const double dual,
+                            const HighsVarType integrality,
+                            double& primal_infeasibility,
+                            double& dual_infeasibility, uint8_t& at_status,
+                            uint8_t& mid_status, const HighsInt index = 0);
+
+void lpNoBasisKktCheck(HighsModelStatus& model_status, HighsInfo& info,
+                       const HighsLp& lp, const HighsSolution& solution,
+                       const HighsOptions& options, const std::string& message);
+
+void lpKktCheck(HighsModelStatus& model_status, HighsInfo& info,
+                const HighsLp& lp, const HighsSolution& solution,
+                const HighsBasis& basis, const HighsOptions& options,
+                const std::string& message);
+
+void getPrimalDualGlpsolErrors(const HighsOptions& options, const HighsLp& lp,
+                               const std::vector<double>& gradient,
+                               const HighsSolution& solution,
+                               HighsPrimalDualErrors& primal_dual_errors);
+
+void getPrimalDualBasisErrors(const HighsOptions& options, const HighsLp& lp,
+                              const HighsSolution& solution,
+                              const HighsBasis& basis,
+                              HighsPrimalDualErrors& primal_dual_errors);
+
+bool getComplementarityViolations(const HighsLp& lp,
+                                  const HighsSolution& solution,
+                                  const double optimality_tolerance,
+                                  HighsInt& num_complementarity_violations,
+                                  double& max_complementarity_violation);
+
+bool computeDualObjectiveValue(const HighsModel& model,
+                               const HighsSolution& solution,
+                               double& dual_objective_value);
+
+bool computeDualObjectiveValue(const double* gradient, const HighsLp& lp,
+                               const HighsSolution& solution,
+                               double& dual_objective_value);
+
+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, 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 isColPrimalSolutionRightSize(const HighsLp& lp,
+                                  const HighsSolution& solution);
+bool isRowPrimalSolutionRightSize(const HighsLp& lp,
+                                  const HighsSolution& solution);
+bool isPrimalSolutionRightSize(const HighsLp& lp,
+                               const HighsSolution& solution);
+
+bool isColDualSolutionRightSize(const HighsLp& lp,
+                                const HighsSolution& solution);
+bool isRowDualSolutionRightSize(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);
+
+bool reportKktFailures(const HighsLp& lp, const HighsOptions& options,
+                       const HighsInfo& highs_info,
+                       const std::string& message = "");
+
+#endif  // LP_DATA_HIGHSSOLUTION_H_

data/ext/lpsolver-highs/build/include/highs/lp_data/HighsSolutionDebug.h

@@ -0,0 +1,87 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    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_

data/ext/lpsolver-highs/build/include/highs/lp_data/HighsSolve.h

@@ -0,0 +1,29 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    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 assessExcessiveObjectiveBoundScaling(const HighsLogOptions log_options,
+                                          const HighsModel& model,
+                                          HighsUserScaleData& user_scale_data);
+bool useIpm(const std::string& solver);
+bool usePdlp(const std::string& solver);
+bool useHipo(const HighsOptions& options,
+             const std::string& specific_solver_option, const HighsLp& lp,
+             const bool logging = false);
+#endif  // LP_DATA_HIGHSSOLVE_H_

data/ext/lpsolver-highs/build/include/highs/lp_data/HighsStatus.h

@@ -0,0 +1,29 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    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