lpsolver 0.1.0 → 0.2.1

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

@@ -0,0 +1,430 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file lp_data/HConst.h
+ * @brief Constants for HiGHS
+ */
+#ifndef LP_DATA_HCONST_H_
+#define LP_DATA_HCONST_H_
+
+#include <cmath>
+#include <limits>
+#include <string>
+
+#include "util/HighsInt.h"
+
+const std::string kHighsCopyrightStatement =
+#ifdef HIPO
+    "Copyright (c) 2026 under Apache 2.0 license terms";
+#else
+    "Copyright (c) 2026 under MIT licence terms";
+#endif
+
+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;
+const std::string kHighsOffString = "off";
+const std::string kHighsChooseString = "choose";
+const std::string kHighsOnString = "on";
+const HighsInt kHighsMaxStringLength = 512;
+const HighsInt kSimplexConcurrencyLimit = 8;
+const double kRunningAverageMultiplier = 0.05;
+
+const double kExcessivelySmallObjectiveCoefficient = 1e-4;
+const double kExcessivelyLargeObjectiveCoefficient = 1e6;
+const double kExcessivelySmallBoundValue = 1e-4;
+const double kExcessivelyLargeBoundValue = 1e6;
+
+const HighsInt kNoThreadInstance = -1;
+const bool kAllowDeveloperAssert = false;
+const bool kExtendInvertWhenAddingRows = false;
+
+enum class HighsLogType { kInfo = 1, kDetailed, kVerbose, kWarning, kError };
+
+enum SimplexScaleStrategy {
+  kSimplexScaleStrategyMin = 0,
+  kSimplexScaleStrategyOff = kSimplexScaleStrategyMin,  // 0
+  kSimplexScaleStrategyChoose,                          // 1
+  kSimplexScaleStrategyEquilibration,                   // 2
+  kSimplexScaleStrategyForcedEquilibration,             // 3
+  kSimplexScaleStrategyMaxValue,                        // 4
+  kSimplexScaleStrategyMaxValue015 = kSimplexScaleStrategyMaxValue,
+  kSimplexScaleStrategyMaxValue0157 = kSimplexScaleStrategyMaxValue,
+  kSimplexScaleStrategyMax = kSimplexScaleStrategyMaxValue
+};
+
+enum HighsDebugLevel {
+  kHighsDebugLevelNone = 0,
+  kHighsDebugLevelCheap,
+  kHighsDebugLevelCostly,
+  kHighsDebugLevelExpensive,
+  kHighsDebugLevelMin = kHighsDebugLevelNone,
+  kHighsDebugLevelMax = kHighsDebugLevelExpensive
+};
+
+enum class HighsDebugStatus {
+  kNotChecked = -1,
+  kOk,
+  kSmallError,
+  kWarning,
+  kLargeError,
+  kError,
+  kExcessiveError,
+  kLogicalError,
+};
+
+enum HighsAnalysisLevel {
+  kHighsAnalysisLevelNone = 0,
+  kHighsAnalysisLevelModelData = 1,
+  kHighsAnalysisLevelSolverSummaryData = 2,
+  kHighsAnalysisLevelSolverRuntimeData = 4,
+  kHighsAnalysisLevelSolverTime = 8,
+  kHighsAnalysisLevelNlaData = 16,
+  kHighsAnalysisLevelNlaTime = 32,
+  kHighsAnalysisLevelMipData = 64,
+  kHighsAnalysisLevelMipTime = 128,
+  kHighsAnalysisLevelMin = kHighsAnalysisLevelNone,
+  kHighsAnalysisLevelMax =
+      kHighsAnalysisLevelModelData + kHighsAnalysisLevelSolverSummaryData +
+      kHighsAnalysisLevelSolverRuntimeData + kHighsAnalysisLevelSolverTime +
+      kHighsAnalysisLevelNlaData + kHighsAnalysisLevelNlaTime +
+      kHighsAnalysisLevelMipData + kHighsAnalysisLevelMipTime
+};
+
+enum class HighsVarType : uint8_t {
+  kContinuous = 0,
+  kInteger = 1,
+  kSemiContinuous = 2,
+  kSemiInteger = 3,
+  kImplicitInteger = 4,
+};
+
+enum class HighsOptionType { kBool = 0, kInt, kDouble, kString };
+
+enum class HighsInfoType { kInt64 = -1, kInt = 1, kDouble };
+
+enum OptionOffChooseOn {
+  kHighsOptionOff = -1,
+  kHighsOptionChoose,
+  kHighsOptionOn
+};
+
+enum IpxDualizeStrategy {
+  kIpxDualizeStrategyOff = kHighsOptionOff,
+  kIpxDualizeStrategyChoose = kHighsOptionChoose,
+  kIpxDualizeStrategyOn = kHighsOptionOn,
+  kIpxDualizeStrategyLukas,
+  kIpxDualizeStrategyFilippo,
+  kIpxDualizeStrategyMin = kIpxDualizeStrategyOff,
+  kIpxDualizeStrategyMax = kIpxDualizeStrategyFilippo,
+};
+
+/** SCIP/HiGHS Objective sense */
+enum class ObjSense { kMinimize = 1, kMaximize = -1 };
+
+enum class MatrixFormat { kColwise = 1, kRowwise, kRowwisePartitioned };
+
+enum class HessianFormat { kTriangular = 1, kSquare };
+
+enum SolutionStatus {
+  kSolutionStatusNone = 0,
+  kSolutionStatusInfeasible,
+  kSolutionStatusFeasible,
+  kSolutionStatusMin = kSolutionStatusNone,
+  kSolutionStatusMax = kSolutionStatusFeasible
+};
+
+enum BasisValidity {
+  kBasisValidityInvalid = 0,
+  kBasisValidityValid,
+  kBasisValidityMin = kBasisValidityInvalid,
+  kBasisValidityMax = kBasisValidityValid
+};
+
+const std::string kHighsBasisFileV1 = "v1";  // Deprecated
+const std::string kHighsBasisFileV2 = "v2";
+
+enum SolutionStyle {
+  kSolutionStyleOldRaw = -1,
+  kSolutionStyleRaw = 0,
+  kSolutionStylePretty,        // 1;
+  kSolutionStyleGlpsolRaw,     // 2;
+  kSolutionStyleGlpsolPretty,  // 3;
+  kSolutionStyleSparse,        // 4;
+  kSolutionStyleMin = kSolutionStyleOldRaw,
+  kSolutionStyleMax = kSolutionStyleSparse
+};
+
+enum GlpsolCostRowLocation {
+  kGlpsolCostRowLocationLast = -2,
+  kGlpsolCostRowLocationNone,         // -1
+  kGlpsolCostRowLocationNoneIfEmpty,  // 0
+  kGlpsolCostRowLocationMin = kGlpsolCostRowLocationLast
+};
+
+const std::string kHighsFilenameDefault = "";
+const std::string kHighsMinimalColNamePrefix = "c";
+const std::string kHighsMinimalrowNamePrefix = "r";
+const std::string kHighsUniqueColNamePrefix = "c_ekk";
+const std::string kHighsUniquerowNamePrefix = "r_ekk";
+
+enum class HighsPresolveStatus {
+  kNotPresolved = -1,
+  kNotReduced,
+  kInfeasible,
+  kUnboundedOrInfeasible,
+  kReduced,
+  kReducedToEmpty,
+  kTimeout,
+  kNullError,     // V2.0: Delete since it's not used!
+  kOptionsError,  // V2.0: Delete since it's not used!
+  kNotSet,
+  kOutOfMemory,  // V2.0: Move above kNotSet
+};
+
+enum class HighsPostsolveStatus {  // V2.0: Delete if not used!
+  kNotPresolved = -1,
+  kNoPrimalSolutionError,
+  kSolutionRecovered,
+  kBasisError
+};
+
+enum class HighsModelStatus {
+  // NB Add new status values to the end so that int cast of status
+  // values is unchanged, since enums are not preserved in some
+  // interfaces
+  kNotset = 0,
+  kLoadError,  // V2.0: Delete since it's not used!
+  kModelError,
+  kPresolveError,  // V2.0: Delete since it's not used!
+  kSolveError,
+  kPostsolveError,  // V2.0: Delete if not used! Add to documentation if used
+  kModelEmpty,
+  kOptimal,
+  kInfeasible,
+  kUnboundedOrInfeasible,
+  kUnbounded,
+  kObjectiveBound,
+  kObjectiveTarget,
+  kTimeLimit,
+  kIterationLimit,
+  // V2.0: put kUnknown after kSolutionLimit and kInterrupt - and then
+  // modify kMax and highs_c_api.h, highs_csharp_api.cs,
+  // highspy/highs_bindings.cpp
+  kUnknown,
+  kSolutionLimit,
+  kInterrupt,
+  kMemoryLimit,
+  kHighsInterrupt,
+  kMin = kNotset,
+  kMax = kHighsInterrupt
+};
+
+enum HighsCallbackType : int {
+  kCallbackMin = 0,
+  kCallbackLogging = kCallbackMin,    // 0
+  kCallbackSimplexInterrupt,          // 1
+  kCallbackIpmInterrupt,              // 2
+  kCallbackMipSolution,               // 3
+  kCallbackMipImprovingSolution,      // 4
+  kCallbackMipLogging,                // 5
+  kCallbackMipInterrupt,              // 6
+  kCallbackMipGetCutPool,             // 7
+  kCallbackMipDefineLazyConstraints,  // 8
+  kCallbackMipUserSolution,           // 9
+  kCallbackMax = kCallbackMipUserSolution,
+  kNumCallbackType
+};
+
+/** SCIP/CPLEX-like HiGHS basis status for columns and rows. */
+enum class HighsBasisStatus : uint8_t {
+  kLower =
+      0,   // (slack) variable is at its lower bound [including fixed variables]
+  kBasic,  // (slack) variable is basic
+  kUpper,  // (slack) variable is at its upper bound
+  kZero,   // free variable is nonbasic and set to zero
+  kNonbasic  // nonbasic with no specific bound information - useful for users
+             // and postsolve
+};
+
+// Types of LP presolve rules
+enum PresolveRuleType : int {
+  kPresolveRuleIllegal = -1,
+  kPresolveRuleMin = 0,
+  kPresolveRuleEmptyRow = kPresolveRuleMin,
+  kPresolveRuleSingletonRow,
+  kPresolveRuleRedundantRow,
+  kPresolveRuleEmptyCol,
+  kPresolveRuleFixedCol,
+  kPresolveRuleDominatedCol,
+  // The remaining rules can be switched off
+  kPresolveRuleFirstAllowOff,
+  kPresolveRuleForcingRow = kPresolveRuleFirstAllowOff,
+  kPresolveRuleForcingCol,
+  kPresolveRuleFreeColSubstitution,
+  kPresolveRuleDoubletonEquation,
+  kPresolveRuleDependentEquations,
+  kPresolveRuleDependentFreeCols,
+  kPresolveRuleAggregator,
+  kPresolveRuleParallelRowsAndCols,
+  kPresolveRuleSparsify,
+  kPresolveRuleProbing,
+  kPresolveRuleEnumeration,
+  kPresolveRuleMax = kPresolveRuleEnumeration,
+  kPresolveRuleLastAllowOff = kPresolveRuleMax,
+  kPresolveRuleCount
+};
+
+enum IisStrategy : int {
+  kIisStrategyMin = 0,
+  kIisStrategyLight = kIisStrategyMin,  // 0
+  kIisStrategyFromRay = 1,
+  kIisStrategyFromLp = 2,
+  kIisStrategyIrreducible = 4,
+  kIisStrategyColPriority = 8,
+  kIisStrategyRelaxation = 16,
+  kIisStrategyDefault = kIisStrategyLight,
+  kIisStrategyMax = kIisStrategyFromRay + kIisStrategyFromLp +
+                    kIisStrategyIrreducible + kIisStrategyColPriority +
+                    kIisStrategyRelaxation
+};
+
+enum IisStatus : int {
+  kIisStatusMin = -1,
+  kIisStatusNotInConflict = kIisStatusMin,  // -1
+  kIisStatusMaybeInConflict,                // 0
+  kIisStatusInConflict,                     // 1
+  kIisStatusMax = kIisStatusInConflict
+};
+
+enum SubSolverIndex : int {
+  kSubSolverMip = 0,
+  kSubSolverDuSimplexBasis,
+  kSubSolverDuSimplexNoBasis,
+  kSubSolverPrSimplexBasis,
+  kSubSolverPrSimplexNoBasis,
+  kSubSolverHipo,
+  kSubSolverIpx,
+  kSubSolverHipoAc,
+  kSubSolverIpxAc,
+  kSubSolverPdlp,
+  kSubSolverQpAsm,
+  kSubSolverSubMip,
+  kSubSolverCount
+};
+
+// Minimum and default KKT tolerance
+const double kMinimumKktTolerance = 1e-10;
+const double kDefaultKktTolerance = 1e-7;
+
+// Minimum and default MIP tolerance
+const double kMinimumMipTolerance = 1e-10;
+const double kDefaultMipTolerance = 1e-6;
+
+// Minimum and default IPM optimality tolerance
+const double kMinimumIpmTolerance = 1e-12;
+const double kDefaultIpmTolerance = 1e-1 * kDefaultKktTolerance;
+
+// Default QP Hessian regularization value
+const double kHessianRegularizationValue = 1e-7;
+
+// Default and max allowed power-of-two matrix scale factor
+const HighsInt kDefaultAllowedMatrixPow2Scale = 20;
+const HighsInt kMaxAllowedMatrixPow2Scale = 30;
+
+// Illegal values of num/max/sum infeasibility - used to indicate that true
+// values aren't known
+const double kHighsIllegalInfeasibilityMeasure = kHighsInf;
+const HighsInt kHighsIllegalInfeasibilityCount = -1;
+
+// Illegal values of num/max/sum residual - used to indicate that true
+// values aren't known
+const double kHighsIllegalResidualMeasure = kHighsInf;
+const HighsInt kHighsIllegalResidualCount = -1;
+
+// Illegal values for HighsError - used to indicate that true
+// values aren't known
+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;
+const HighsInt kHighsIllegalComplementarityCount = -1;
+
+// Maximum upper bound on semi-variables
+const double kMaxSemiVariableUpper = 1e5;
+
+// Limit on primal values being realistic
+const double kExcessivePrimalValue = 1e25;
+
+// Hash marker for duplicates
+const HighsInt kHashIsDuplicate = -1;
+
+// Tolerance values for highsDoubleToString
+const double kModelValueToStringTolerance = 1e-15;
+const double kRangingValueToStringTolerance = 1e-13;
+const double kHighsSolutionValueToStringTolerance = 1e-13;
+const double kGlpsolSolutionValueToStringTolerance = 1e-12;
+
+// Termination link in linked lists
+const HighsInt kNoLink = -1;
+
+const int8_t kPivotIllegal = -1;
+const int8_t kPivotLogical = 0;
+const int8_t kPivotUnit = 1;
+const int8_t kPivotRowSingleton = 2;
+const int8_t kPivotColSingleton = 3;
+const int8_t kPivotMarkowitz = 4;
+
+// For converting general LPs to form for PDLP
+//
+// Requires non-conforming names for cuPDLP-C
+enum ConstraintType { EQ = 0, LEQ, GEQ, BOUND, FREE };
+
+// Mask for switching off PDLP features
+enum PdlpFeaturesOff {
+  kPdlpAllFeaturesOn = 0,
+  kPdlpScalingOff = 1,
+  kPdlpRestartOff = 2,
+  kPdlpAdaptiveStepSizeOff = 4,
+  kPdlpAllFeaturesOff =
+      kPdlpScalingOff + kPdlpRestartOff + kPdlpAdaptiveStepSizeOff
+};
+
+enum PdlpScalingBit {
+  kPdlpScalingMin = 0,
+  kPdlpScalingRuiz = 1,
+  kPdlpScalingL2 = 2,
+  kPdlpScalingPC = 4,
+  kPdlpScalingMax = kPdlpScalingRuiz + kPdlpScalingL2 + kPdlpScalingPC
+};
+
+enum PdlpStepSizeStrategy {
+  kPdlpStepSizeStrategyFixed = 0,
+  kPdlpStepSizeStrategyMin = kPdlpStepSizeStrategyFixed,
+  kPdlpStepSizeStrategyAdaptive,
+  kPdlpStepSizeStrategyMalitskyPock,
+  kPdlpStepSizeStrategyPid,
+  kPdlpStepSizeStrategyMax = kPdlpStepSizeStrategyPid
+};
+
+enum PdlpRestartStrategy {
+  kPdlpRestartStrategyOff = 0,
+  kPdlpRestartStrategyMin = kPdlpRestartStrategyOff,
+  kPdlpRestartStrategyFixed,
+  kPdlpRestartStrategyAdaptive,
+  kPdlpRestartStrategyHalpern,
+  kPdlpRestartStrategyMax = kPdlpRestartStrategyHalpern
+};
+
+#endif /* LP_DATA_HCONST_H_ */

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

@@ -0,0 +1,213 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file lp_data/HStruct.h
+ * @brief Structs for HiGHS
+ */
+#ifndef LP_DATA_HSTRUCT_H_
+#define LP_DATA_HSTRUCT_H_
+
+#include <unordered_map>
+#include <vector>
+
+#include "lp_data/HConst.h"
+
+struct HighsSolution {
+  bool value_valid = false;
+  bool dual_valid = false;
+  std::vector<double> col_value;
+  std::vector<double> col_dual;
+  std::vector<double> row_value;
+  std::vector<double> row_dual;
+  bool hasUndefined() const;
+  void invalidate();
+  void clear();
+  void print(const std::string& prefix = "",
+             const std::string& message = "") const;
+};
+
+struct HighsObjectiveSolution {
+  double objective;
+  std::vector<double> col_value;
+  void clear();
+};
+
+struct RefactorInfo {
+  bool use = false;
+  std::vector<HighsInt> pivot_row;
+  std::vector<HighsInt> pivot_var;
+  std::vector<int8_t> pivot_type;
+  double build_synthetic_tick;
+  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;
+};
+
+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(const std::string& prefix = "",
+             const std::string& message = "") const;
+  void printScalars(const std::string& prefix = "",
+                    const std::string& message = "") const;
+  void invalidate();
+  void clear();
+};
+
+struct HighsScale {
+  HighsInt strategy;
+  bool has_scaling;
+  HighsInt num_col;
+  HighsInt num_row;
+  double cost;
+  std::vector<double> col;
+  std::vector<double> row;
+};
+
+struct HighsLpMods {
+  // Semi-variables with zero lower bound that are treated as non-semi
+  std::vector<HighsInt> save_non_semi_variable_index;
+
+  // Semi-variables with inconsistent bounds that are fixed at zero
+  std::vector<HighsInt> save_inconsistent_semi_variable_index;
+  std::vector<double> save_inconsistent_semi_variable_lower_bound_value;
+  std::vector<double> save_inconsistent_semi_variable_upper_bound_value;
+  std::vector<HighsVarType> save_inconsistent_semi_variable_type;
+
+  // Semi-variables whose lower bound is ignored when solving the
+  // relaxation
+  std::vector<HighsInt> save_relaxed_semi_variable_lower_bound_index;
+  std::vector<double> save_relaxed_semi_variable_lower_bound_value;
+
+  // Semi-variables whose upper bound is too large to be used as a
+  // big-M when converting them to an integer variables plus an
+  // integer/continuous variables as appropriate
+  std::vector<HighsInt> save_tightened_semi_variable_upper_bound_index;
+  std::vector<double> save_tightened_semi_variable_upper_bound_value;
+
+  // Variables with infinite costs that are fixed during solve
+  std::vector<HighsInt> save_inf_cost_variable_index;
+  std::vector<double> save_inf_cost_variable_cost;
+  std::vector<double> save_inf_cost_variable_lower;
+  std::vector<double> save_inf_cost_variable_upper;
+
+  void clear();
+  bool isClear();
+};
+
+struct HighsNameHash {
+  std::unordered_map<std::string, int> name2index;
+  void form(const std::vector<std::string>& name);
+  bool hasDuplicate(const std::vector<std::string>& name);
+  void update(int index, const std::string& old_name,
+              const std::string& new_name);
+  void clear();
+};
+
+struct HighsPresolveRuleLog {
+  HighsInt call;
+  HighsInt col_removed;
+  HighsInt row_removed;
+};
+
+struct HighsPresolveLog {
+  std::vector<HighsPresolveRuleLog> rule;
+  void clear();
+};
+
+struct HighsIllConditioningRecord {
+  HighsInt index;
+  double multiplier;
+};
+
+struct HighsIllConditioning {
+  std::vector<HighsIllConditioningRecord> record;
+  void clear();
+};
+
+struct HighsLinearObjective {
+  double weight = 0;
+  double offset = 0;
+  std::vector<double> coefficients;
+  double abs_tolerance = -1;
+  double rel_tolerance = -1;
+  HighsInt priority = 0;
+  void clear();
+};
+
+struct HighsSubSolverCallTime {
+  std::vector<std::string> name;
+  std::vector<HighsInt> num_call;
+  std::vector<double> run_time;
+  void initialise();
+  void add(const HighsSubSolverCallTime& sub_solver_call_time,
+           const bool analytic_centre = false);
+};
+
+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);
+};
+
+struct HighsUserScaleData {
+  HighsInt user_objective_scale = 0;
+  HighsInt user_bound_scale = 0;
+  double infinite_cost;
+  double infinite_bound;
+  double small_matrix_value;
+  double large_matrix_value;
+  HighsInt num_infinite_costs;
+  HighsInt num_infinite_hessian_values;
+  HighsInt num_infinite_col_bounds;
+  HighsInt num_infinite_row_bounds;
+  HighsInt num_small_matrix_values;
+  HighsInt num_large_matrix_values;
+  HighsInt suggested_user_objective_scale;
+  HighsInt suggested_user_bound_scale;
+  bool applied = false;
+  void initialise(const HighsInt& user_objective_scale_,
+                  const HighsInt& user_bound_scale_,
+                  const double& infinite_cost_, const double& infinite_bound_,
+                  const double& small_matrix_value_,
+                  const double& large_matrix_value_);
+  bool scaleError(std::string& message) const;
+  bool scaleWarning(std::string& message) const;
+};
+
+#endif /* LP_DATA_HSTRUCT_H_ */

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

@@ -0,0 +1,23 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file lp_data/HighsAnalysis.h
+ * @brief
+ */
+#ifndef LP_DATA_HIGHS_ANALYSIS_H_
+#define LP_DATA_HIGHS_ANALYSIS_H_
+
+#include <vector>
+
+#include "HConfig.h"
+#include "util/HighsTimer.h"
+
+struct HighsTimerClock {
+  HighsTimer* timer_pointer_;
+  std::vector<HighsInt> clock_;
+};
+#endif /* LP_DATA_HIGHS_ANALYSIS_H_ */