Numeric limits for Int and double now use constants in HConts.h

Author: filikat

highs/ipm/hipo/auxiliary/IntConfig.h

@@ -2,6 +2,7 @@
 #define HIPO_INT_CONFIG_H
 
 #include "util/HighsInt.h"
+#include "lp_data/HConst.h"
 
 namespace hipo {
 

highs/ipm/hipo/factorhighs/Analyse.cpp

@@ -2,7 +2,6 @@
 
 #include <fstream>
 #include <iostream>
-#include <climits>
 #include <random>
 #include <stack>
 
@@ -429,7 +428,7 @@ void Analyse::relaxSupernodes() {
         Int child = first_child[sn];
 
         // info for first criterion
-        Int nz_fakenz = INT_MAX;
+        Int nz_fakenz = kHighsIInf;
         Int size_fakenz = 0;
         Int child_fakenz = -1;
 
@@ -566,7 +565,7 @@ void Analyse::relaxSupernodesSize() {
       Int child = first_child[sn];
 
       // info for first criterion
-      Int size_smallest = INT_MAX;
+      Int size_smallest = kHighsIInf;
       Int child_smallest = -1;
       Int nz_smallest = 0;
 
@@ -1386,7 +1385,7 @@ Int Analyse::run(Symbolic& S) {
   // Too many nonzeros for the integer type selected.
   // Check after statistics have been moved into S, so that info is accessible
   // for debug logging.
-  if (nz_factor_ >= std::numeric_limits<Int>::max()) {
+  if (nz_factor_ >= kHighsIInf) {
     if (log_) log_->printDevInfo("Integer overflow in analyse phase\n");
     return kRetIntOverflow;
   }

highs/ipm/hipo/factorhighs/DataCollector.h

@@ -16,9 +16,9 @@ namespace hipo {
 struct IterData {
 // data of one factorisation
 #ifdef HIPO_COLLECT_EXPENSIVE_DATA
-  double minD = std::numeric_limits<double>::max();
+  double minD = kHighsInf;
   double maxD = 0.0;
-  double minL = std::numeric_limits<double>::max();
+  double minL = kHighsInf;
   double maxL = 0.0;
   double max_reg = 0.0;
   Int n_reg_piv = 0;

highs/ipm/hipo/factorhighs/Factorise.cpp

@@ -66,7 +66,7 @@ Factorise::Factorise(const Symbolic& S, const std::vector<Int>& rowsA,
 
   // compute largest diagonal entry in absolute value
   max_diag_ = 0.0;
-  min_diag_ = std::numeric_limits<double>::max();
+  min_diag_ = kHighsInf;
   for (Int col = 0; col < n_; ++col) {
     double val = std::abs(valA_[ptrA_[col]]);
     max_diag_ = std::max(max_diag_, val);

highs/ipm/hipo/factorhighs/SymScaling.cpp

@@ -171,7 +171,7 @@ void JacekScalingSym(const std::vector<Int>& ptr, const std::vector<Int>& rows,
   for (Int iter = 0; iter < 10; ++iter) {
     // inf norm of columns
     std::vector<double> col_norms(n);
-    std::vector<double> col_min(n, std::numeric_limits<double>::max());
+    std::vector<double> col_min(n, kHighsInf);
     for (Int col = 0; col < n; ++col) {
       for (Int el = ptr[col]; el < ptr[col + 1]; ++el) {
         Int row = rows[el];

highs/ipm/hipo/ipm/FactorHiGHSSolver.cpp

@@ -479,8 +479,7 @@ Int FactorHiGHSSolver::chooseNla() {
     // If NE has more nonzeros than the factor of AS, then it's likely that AS
     // will be preferred, so stop computation of NE.
     int64_t NE_nz_limit = symb_AS.nz() * kSymbNzMult;
-    if (failure_AS || NE_nz_limit > std::numeric_limits<Int>::max())
-      NE_nz_limit = std::numeric_limits<Int>::max();
+    if (failure_AS || NE_nz_limit > kHighsIInf) NE_nz_limit = kHighsIInf;
 
     Int NE_status = analyseNE(symb_NE, NE_nz_limit);
     if (NE_status) failure_NE = true;

highs/ipm/hipo/ipm/FactorHiGHSSolver.h

@@ -40,16 +40,14 @@ class FactorHiGHSSolver : public LinearSolver {
   Int setNla();
   void setParallel();
   Int buildNEstructureDense(const HighsSparseMatrix& A,
-                            int64_t nz_limit = std::numeric_limits<Int>::max());
-  Int buildNEstructureSparse(
-      const HighsSparseMatrix& A,
-      int64_t nz_limit = std::numeric_limits<Int>::max());
+                            int64_t nz_limit = kHighsIInf);
+  Int buildNEstructureSparse(const HighsSparseMatrix& A,
+                             int64_t nz_limit = kHighsIInf);
   Int buildNEvalues(const HighsSparseMatrix& A,
                     const std::vector<double>& scaling);
 
   Int analyseAS(Symbolic& S);
-  Int analyseNE(Symbolic& S,
-                int64_t nz_limit = std::numeric_limits<Int>::max());
+  Int analyseNE(Symbolic& S, int64_t nz_limit = kHighsIInf);
 
  public:
   FactorHiGHSSolver(Options& options, const Model& model,

highs/ipm/hipo/ipm/Iterate.cpp

@@ -84,7 +84,7 @@ void Iterate::computeScaling() {
   }
 
   // compute extremes of theta
-  data.back().min_theta = std::numeric_limits<double>::infinity();
+  data.back().min_theta = kHighsInf;
   data.back().max_theta = 0.0;
   for (double d : scaling) {
     if (d != 0.0) {
@@ -99,7 +99,7 @@ void Iterate::products() {
   Int& num_small = data.back().num_small_prod;
   Int& num_large = data.back().num_large_prod;
 
-  min_prod = std::numeric_limits<double>::max();
+  min_prod = kHighsInf;
   max_prod = 0.0;
   num_small = 0;
   num_large = 0;

highs/ipm/hipo/ipm/Solver.cpp

@@ -1222,7 +1222,7 @@ void Solver::backwardError(const NewtonDir& delta) const {
       }
 
       if (denom == 0.0) {
-        if (num != 0.0) cw_back_err = std::numeric_limits<double>::max();
+        if (num != 0.0) cw_back_err = kHighsInf;
       } else {
         const double temp = num / denom;
         cw_back_err = std::max(cw_back_err, temp);
@@ -1244,7 +1244,7 @@ void Solver::backwardError(const NewtonDir& delta) const {
         }
 
         if (denom == 0.0) {
-          if (num != 0.0) cw_back_err = std::numeric_limits<double>::max();
+          if (num != 0.0) cw_back_err = kHighsInf;
         } else {
           const double temp = num / denom;
           cw_back_err = std::max(cw_back_err, temp);
@@ -1264,7 +1264,7 @@ void Solver::backwardError(const NewtonDir& delta) const {
         }
 
         if (denom == 0.0) {
-          if (num != 0.0) cw_back_err = std::numeric_limits<double>::max();
+          if (num != 0.0) cw_back_err = kHighsInf;
         } else {
           const double temp = num / denom;
           cw_back_err = std::max(cw_back_err, temp);
@@ -1290,7 +1290,7 @@ void Solver::backwardError(const NewtonDir& delta) const {
       }
 
       if (denom == 0.0) {
-        if (num != 0.0) cw_back_err = std::numeric_limits<double>::max();
+        if (num != 0.0) cw_back_err = kHighsInf;
       } else {
         const double temp = num / denom;
         cw_back_err = std::max(cw_back_err, temp);
@@ -1314,7 +1314,7 @@ void Solver::backwardError(const NewtonDir& delta) const {
         }
 
         if (denom == 0.0) {
-          if (num != 0.0) cw_back_err = std::numeric_limits<double>::max();
+          if (num != 0.0) cw_back_err = kHighsInf;
         } else {
           const double temp = num / denom;
           cw_back_err = std::max(cw_back_err, temp);
@@ -1336,7 +1336,7 @@ void Solver::backwardError(const NewtonDir& delta) const {
         }
 
         if (denom == 0.0) {
-          if (num != 0.0) cw_back_err = std::numeric_limits<double>::max();
+          if (num != 0.0) cw_back_err = kHighsInf;
         } else {
           const double temp = num / denom;
           cw_back_err = std::max(cw_back_err, temp);