ENH: Scipy exceptions

src/Highs.h

@@ -22,6 +22,7 @@
 #include "lp_data/HighsRanging.h"
 #include "lp_data/HighsSolutionDebug.h"
 #include "model/HighsModel.h"
+#include "util/HighsExceptions.h"
 #include "presolve/ICrash.h"
 #include "presolve/PresolveComponent.h"
 

src/presolve/HPresolve.cpp

@@ -18,6 +18,7 @@
 #include <limits>
 
 #include "Highs.h"
+#include "HighsExceptions.h"
 #include "io/HighsIO.h"
 #include "lp_data/HConst.h"
 #include "lp_data/HStruct.h"
@@ -3993,7 +3994,12 @@ HPresolve::Result HPresolve::presolve(HighsPostsolveStack& postsolve_stack) {
       }
     };
 
-    HPRESOLVE_CHECKED_CALL(initialRowAndColPresolve(postsolve_stack));
+    try {
+      HPRESOLVE_CHECKED_CALL(initialRowAndColPresolve(postsolve_stack));
+    } catch (const DataStackOverflow& e) {
+      // Here we re-throw the error
+      throw PresolveTooLarge(e.what());
+    }
 
     HighsInt numParallelRowColCalls = 0;
 #if ENABLE_SPARSIFY_FOR_LP

src/presolve/HPresolve.h

@@ -33,6 +33,7 @@
 #include "util/HighsHash.h"
 #include "util/HighsLinearSumBounds.h"
 #include "util/HighsMatrixSlice.h"
+#include "util/HighsExceptions.h"
 
 namespace presolve {
 

src/presolve/HighsPostsolveStack.h

@@ -24,6 +24,7 @@
 #include <tuple>
 #include <vector>
 
+#include "HighsExceptions.h"
 #include "lp_data/HConst.h"
 #include "lp_data/HStruct.h"
 #include "lp_data/HighsOptions.h"
@@ -367,17 +368,23 @@ class HighsPostsolveStack {
   template <typename ColStorageFormat>
   void fixedColAtLower(HighsInt col, double fixValue, double colCost,
                        const HighsMatrixSlice<ColStorageFormat>& colVec) {
-    assert(std::isfinite(fixValue));
-    colValues.clear();
-    for (const HighsSliceNonzero& colVal : colVec)
-      colValues.emplace_back(origRowIndex[colVal.index()], colVal.value());
-
-    reductionValues.push(FixedCol{fixValue, colCost, origColIndex[col],
-                                  HighsBasisStatus::kLower});
-    reductionValues.push(colValues);
-    reductionAdded(ReductionType::kFixedCol);
+    try {
+      assert(std::isfinite(fixValue));
+      colValues.clear();
+      for (const HighsSliceNonzero& colVal : colVec)
+        colValues.emplace_back(origRowIndex[colVal.index()], colVal.value());
+
+      reductionValues.push(FixedCol{fixValue, colCost, origColIndex[col],
+                                    HighsBasisStatus::kLower});
+      reductionValues.push(colValues);
+      reductionAdded(ReductionType::kFixedCol);
+    } catch (const DataStackOverflow& e) {
+      std::cerr << "Memory allocation failed while processing fixedColAtLower: "
+                << std::endl;
+      // Rethrow.
+      throw;
+    }
   }
-
   template <typename ColStorageFormat>
   void fixedColAtUpper(HighsInt col, double fixValue, double colCost,
                        const HighsMatrixSlice<ColStorageFormat>& colVec) {

src/util/HighsDataStack.h

@@ -18,9 +18,11 @@
 #define UTIL_HIGHS_DATA_STACK_H_
 
 #include <cstring>
+#include <string>
 #include <type_traits>
 #include <vector>
 
+#include "util/HighsExceptions.h"
 #include "util/HighsInt.h"
 
 #if __GNUG__ && __GNUC__ < 5
@@ -39,11 +41,19 @@ class HighsDataStack {
   template <typename T,
             typename std::enable_if<IS_TRIVIALLY_COPYABLE(T), int>::type = 0>
   void push(const T& r) {
-    std::size_t dataSize = data.size();
-    data.resize(dataSize + sizeof(T));
+    HighsInt dataSize = data.size();
+    HighsInt newSize = dataSize + sizeof(T);
+    try {
+      data.resize(newSize);
+    } catch (const std::length_error& e) {
+      throw DataStackOverflow(
+          "Failed to resize the vector. Requested new size: " +
+          std::to_string(newSize) + ". Size to add is " +
+          std::to_string(sizeof(T)) + "for "+
+          ". Current size: " + std::to_string(data.size()) + ".");
+    }
     std::memcpy(data.data() + dataSize, &r, sizeof(T));
   }
-
   template <typename T,
             typename std::enable_if<IS_TRIVIALLY_COPYABLE(T), int>::type = 0>
   void pop(T& r) {

src/util/HighsExceptions.h

@@ -0,0 +1,21 @@
+#pragma once
+#include <stdexcept>
+
+class DataStackOverflow : public std::runtime_error {
+public:
+    explicit DataStackOverflow(const std::string& msg)
+        : std::runtime_error(msg) {}
+};
+
+class ProblemTooLargeException : public std::runtime_error {
+public:
+    explicit ProblemTooLargeException(const std::string& msg)
+        : std::runtime_error(msg) {}
+};
+
+
+class PresolveTooLarge : public std::runtime_error {
+public:
+    explicit PresolveTooLarge(const std::string& msg)
+        : std::runtime_error(msg) {}
+};