lpsolver 0.1.0 → 0.2.1

data/ext/lpsolver-highs/highs/ipm/ipx/timer.h

@@ -0,0 +1,25 @@
+#ifndef IPX_TIMER_H_
+#define IPX_TIMER_H_
+
+#include <chrono>
+
+namespace ipx {
+    using namespace std::chrono;
+
+class Timer {
+public:
+    Timer(const double offset=0);
+    double Elapsed() const { return toc(t0_); }
+    void Reset(const bool first = false);
+
+private:
+    static double toc(double start) { return read() - start; }
+    static double read() { return duration_cast<duration<double>>(high_resolution_clock::now().time_since_epoch()).count(); }
+    double t0_;
+public:
+    double offset_;
+};
+
+}  // namespace ipx
+
+#endif  // IPX_TIMER_H_

data/ext/lpsolver-highs/highs/ipm/ipx/utils.cc

@@ -0,0 +1,95 @@
+#include "ipm/ipx/utils.h"
+#include <algorithm>
+#include <cassert>
+#include <cmath>
+#include <utility>
+#include "../extern/pdqsort/pdqsort.h"
+
+namespace ipx {
+
+bool AllFinite(const Vector& x) {
+    for (double xi : x)
+        if (!std::isfinite(xi))
+            return false;
+    return true;
+}
+
+double Onenorm(const Vector& x) {
+    double norm = 0.0;
+    for (double xi : x)
+        norm += std::abs(xi);
+    return norm;
+}
+
+double Twonorm(const Vector& x) {
+    double norm = 0.0;
+    for (double xi : x)
+        norm += xi * xi;
+    return std::sqrt(norm);
+}
+
+double Infnorm(const Vector& x) {
+    double norm = 0.0;
+    for (double xi : x)
+        norm = std::max(norm, std::abs(xi));
+    return norm;
+}
+
+double Dot(const Vector& x, const Vector& y) {
+    assert(x.size() == y.size());
+    double d = 0.0;
+    for (size_t i = 0; i < x.size(); i++)
+        d += x[i]*y[i];
+    return d;
+}
+
+Int FindMaxAbs(const Vector& x) {
+    double xmax = 0.0;
+    size_t imax = 0;
+    for (size_t i = 0; i < x.size(); i++) {
+        if (std::abs(x[i]) > xmax) {
+            xmax = std::abs(x[i]);
+            imax = i;
+        }
+    }
+    return static_cast<Int>(imax);
+}
+
+void Permute(const std::vector<Int>& permuted_index, const Vector& rhs,
+             Vector& lhs) {
+    for (size_t i = 0; i < permuted_index.size(); i++)
+        lhs[permuted_index[i]] = rhs[i];
+}
+
+void PermuteBack(const std::vector<Int>& permuted_index, const Vector& rhs,
+                 Vector& lhs) {
+    for (size_t i = 0; i < permuted_index.size(); i++)
+        lhs[i] = rhs[permuted_index[i]];
+}
+
+std::vector<Int> InversePerm(const std::vector<Int>& perm) {
+    std::vector<Int> invperm(perm.size());
+    // at() throws an exception if the index is out of range
+    for (size_t i = 0; i < perm.size(); i++)
+        invperm.at(perm[i]) = static_cast<Int>(i);
+    return invperm;
+}
+
+std::vector<Int> Sortperm(Int m, const double* values, bool reverse) {
+    std::vector<Int> perm(m);
+    for (Int i = 0; i < m; i++) perm[i] = i;
+    if (!values) return perm;
+
+    if (reverse)
+        pdqsort(perm.begin(), perm.end(), [&](Int i, Int j) {
+            return std::make_pair(values[i], i) > std::make_pair(values[j], j);
+        });
+    else
+        pdqsort(perm.begin(), perm.end(), [&](Int i, Int j) {
+            return std::make_pair(values[i], i) < std::make_pair(values[j], j);
+        });
+
+    return perm;
+}
+
+}  // namespace ipx

data/ext/lpsolver-highs/highs/ipm/ipx/utils.h

@@ -0,0 +1,37 @@
+#ifndef IPX_UTILS_H_
+#define IPX_UTILS_H_
+
+#include <vector>
+#include "ipm/ipx/ipx_internal.h"
+
+namespace ipx {
+
+bool AllFinite(const Vector& x);
+
+double Onenorm(const Vector& x);
+double Twonorm(const Vector& x);
+double Infnorm(const Vector& x);
+double Dot(const Vector& x, const Vector& y);
+
+// Returns the index of an entry of maximum absolute value.
+Int FindMaxAbs(const Vector& x);
+
+// lhs[permuted_index] = rhs
+void Permute(const std::vector<Int>& permuted_index, const Vector& rhs,
+             Vector& lhs);
+
+// lhs = rhs[permuted_index]
+void PermuteBack(const std::vector<Int>& permuted_index, const Vector& rhs,
+                 Vector& lhs);
+
+// Returns the inverse permutation to @perm.
+std::vector<Int> InversePerm(const std::vector<Int>& perm);
+
+// Returns the permutation that puts values[0..m-1] in increasing (if reverse is
+// false) or in decreasing (if reverse is true) order. If values==NULL, returns
+// the identity permutation.
+std::vector<Int> Sortperm(Int m, const double* values, bool reverse);
+
+}  // namespace ipx
+
+#endif  // IPX_UTILS_H_

data/ext/lpsolver-highs/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_ */