Removed final residuals calculation

Author: filikat

highs/ipm/hipo/ipm/Iterate.cpp

@@ -443,96 +443,34 @@ Int Iterate::finalResiduals(Info& info) const {
   // compute it.
 
   if (!info.ipx_used) {
-    std::vector<double> x_local, xl_local, xu_local, y_local, zl_local,
-        zu_local, slack_local;
-
-    model.postprocess(x_local, xl_local, xu_local, slack_local, y_local,
-                      zl_local, zu_local, *this);
-
-    Int m, n;
-    HighsSparseMatrix A;
-    std::vector<double> b, c, lower, upper;
-    std::vector<char> constraints;
-    double offset;
-
-    if (!model.lpOrig()) return kStatusError;
-    fillInIpxData(*model.lpOrig(), n, m, offset, c, lower, upper, A.start_,
-                  A.index_, A.value_, b, constraints);
-    A.num_col_ = n;
-    A.num_row_ = m;
-
-    if (model.qp()) {
-      if (!model.QOrig()) return kStatusError;
-    }
-
-    assert(x_local.size() == c.size());
-    assert(y_local.size() == b.size());
-
-    // res1 = b - slack - A*x
-    std::vector<double> res1 = b;
-    vectorAdd(res1, slack_local, -1.0);
-    A.alphaProductPlusY(-1.0, x_local, res1);
-
-    // res2 = lower - x + xl
-    std::vector<double> res2(n);
-    for (Int i = 0; i < n; ++i) {
-      if (std::isfinite(lower[i]))
-        res2[i] = lower[i] - x_local[i] + xl_local[i];
-    }
+    info.p_obj = pobj;
+    info.d_obj = dobj;
+    info.pd_gap = pdgap;
 
-    // res3 = upper - x - xu
-    std::vector<double> res3(n);
-    for (Int i = 0; i < n; ++i) {
-      if (std::isfinite(upper[i]))
-        res3[i] = upper[i] - x_local[i] - xu_local[i];
+    double& pinf = info.p_res_abs;
+    for (Int i = 0; i < model.m(); ++i) {
+      double val = std::abs(res.r1[i]);
+      if (model.scaled()) val /= model.rowScale(i);
+      pinf = std::max(pinf, val);
     }
-
-    // res4 = c - A^T * y - zl + zu + Q * x
-    std::vector<double> res4(n);
-    A.alphaProductPlusY(-1.0, y_local, res4, true);
-    if (model.qp())
-      model.QOrig()->alphaProductPlusY(model.sense(), x_local, res4);
-    for (Int i = 0; i < n; ++i) {
-      if (std::isfinite(lower[i])) res4[i] -= zl_local[i];
-      if (std::isfinite(upper[i])) res4[i] += zu_local[i];
-      res4[i] += c[i];
+    for (Int i = 0; i < model.n(); ++i) {
+      double val = std::abs(res.r2[i]);
+      if (model.scaled()) val *= model.colScale(i);
+      pinf = std::max(pinf, val);
+
+      val = std::abs(res.r3[i]);
+      if (model.scaled()) val *= model.colScale(i);
+      pinf = std::max(pinf, val);
     }
+    info.p_res_rel = pinf / (1.0 + model.normUnscaledRhs());
 
-    double norm_rhs = infNorm(b);
-    for (Int i = 0; i < n; ++i) {
-      if (std::isfinite(lower[i]))
-        norm_rhs = std::max(norm_rhs, std::abs(lower[i]));
-      if (std::isfinite(upper[i]))
-        norm_rhs = std::max(norm_rhs, std::abs(upper[i]));
+    double& dinf = info.d_res_abs;
+    for (Int i = 0; i < model.n(); ++i) {
+      double val = std::abs(res.r4[i]);
+      if (model.scaled()) val /= model.colScale(i);
+      dinf = std::max(dinf, val);
     }
-
-    info.p_res_abs = infNorm(res1);
-    info.p_res_abs = std::max(info.p_res_abs, infNorm(res2));
-    info.p_res_abs = std::max(info.p_res_abs, infNorm(res3));
-    info.p_res_rel = info.p_res_abs / (1.0 + norm_rhs);
-
-    info.d_res_abs = infNorm(res4);
-    info.d_res_rel = info.d_res_abs / (1.0 + infNorm(c));
-
-    const double quad_term_local =
-        model.qp() ? model.sense() * model.QOrig()->objectiveValue(x_local)
-                   : 0.0;
-
-    double pobj = offset;
-    pobj += dotProd(c, x_local);
-    pobj += quad_term_local;
-
-    double dobj = offset;
-    dobj += dotProd(y_local, b);
-    for (Int i = 0; i < n; ++i) {
-      if (std::isfinite(lower[i])) dobj += lower[i] * zl_local[i];
-      if (std::isfinite(upper[i])) dobj -= upper[i] * zu_local[i];
-    }
-    dobj -= quad_term_local;
-
-    info.p_obj = pobj;
-    info.d_obj = dobj;
-    info.pd_gap = std::abs(pobj - dobj) / (1.0 + 0.5 * std::abs(pobj + dobj));
+    info.d_res_rel = dinf / (1.0 + model.normUnscaledObj());
 
   } else {
     info.p_res_abs = info.ipx_info.abs_presidual;

highs/ipm/hipo/ipm/Iterate.h

@@ -151,10 +151,6 @@ struct Iterate {
                              std::vector<double>& y_cmp,
                              std::vector<double>& z_cmp) const;
 
-  // ===================================================================================
-  // Compute residuals after solution has been found, postprocessed and
-  // unscaled.
-  // ===================================================================================
   Int finalResiduals(Info& info) const;
 
   // ===================================================================================

highs/ipm/hipo/ipm/Model.cpp

@@ -20,7 +20,6 @@ Int Model::init(const HighsLp& lp, const HighsHessian& Q) {
   if (checkData()) return kStatusBadModel;
 
   lp_orig_ = &lp;
-  Q_orig_ = &Q;
   n_orig_ = n_;
   m_orig_ = m_;
   A_.num_col_ = n_;

highs/ipm/hipo/ipm/Model.h

@@ -34,7 +34,6 @@ class Model {
   Int n_orig_{};
   Int m_orig_{};
   const HighsLp* lp_orig_ = nullptr;
-  const HighsHessian* Q_orig_ = nullptr;
   double offset_;
   ObjSense sense_ = ObjSense::kMinimize;
   std::vector<double> rhs_orig_;
@@ -99,7 +98,6 @@ class Model {
   Int n_orig() const { return n_orig_; }
   Int m_orig() const { return m_orig_; }
   const HighsLp* lpOrig() const { return lp_orig_; }
-  const HighsHessian* QOrig() const { return Q_orig_; }
   const std::vector<double>& rhsOrig() const { return rhs_orig_; }
   const std::vector<char>& constraintsOrig() const { return constraints_orig_; }
   bool qp() const { return !Q_.empty(); }

highs/ipm/hipo/ipm/Solver.cpp

@@ -1132,7 +1132,8 @@ bool Solver::checkBadIter() {
     } else if (stagnation) {
       // stagnation detected, solution may still be good for highs kktCheck
       if (checkTerminationKkt()) {
-        logH_.printw("HiPO stagnated but HiGHS considers the solution acceptable\n");
+        logH_.printw(
+            "HiPO stagnated but HiGHS considers the solution acceptable\n");
         logH_.print("=== Primal-dual feasible point found\n");
         info_.status = kStatusPDFeas;
       } else
@@ -1188,6 +1189,8 @@ bool Solver::checkTerminationKkt() {
   // options, not the original)
   Hoptions_.output_flag = logH_.debug(2);
 
+  if (!model_.lpOrig()) return false;
+
   getHipoNonVertexSolution(Hoptions_, *model_.lpOrig(), model_.n_orig(),
                            model_.m_orig(), model_.rhsOrig(),
                            model_.constraintsOrig(), *this, model_status,
@@ -1302,32 +1305,6 @@ void Solver::printSummary() const {
     log_stream << textline("IPX iterations:") << integer(info_.ipx_info.iter)
                << "\n";
 
-  if (info_.status >= kStatusImprecise) {
-    log_stream << textline("Primal residual rel/abs:")
-               << sci(info_.p_res_rel, 0, 2) << " / "
-               << sci(info_.p_res_abs, 0, 2) << '\n';
-
-    log_stream << textline("Dual residual rel/abs:")
-               << sci(info_.d_res_rel, 0, 2) << " / "
-               << sci(info_.d_res_abs, 0, 2) << '\n';
-
-    log_stream << textline("Primal objective") << sci(info_.p_obj, 0, 8)
-               << '\n';
-    log_stream << textline("Dual objective") << sci(info_.d_obj, 0, 8) << '\n';
-
-    log_stream << textline("Primal-dual gap:") << sci(info_.pd_gap, 0, 2)
-               << '\n';
-  }
-
-  if (info_.ipx_used &&
-      (info_.ipx_info.status_crossover == IPX_STATUS_optimal ||
-       info_.ipx_info.status_crossover == IPX_STATUS_imprecise)) {
-    log_stream << textline("Basis solution primal infeas:")
-               << sci(info_.ipx_info.primal_infeas, 0, 2) << '\n';
-    log_stream << textline("Basis solution dual infeas:")
-               << sci(info_.ipx_info.dual_infeas, 0, 2) << '\n';
-  }
-
   if (logH_.debug(1)) {
     log_stream << textline("Correctors:") << integer(info_.correctors) << '\n';
     log_stream << textline("Factorisations:") << integer(info_.factor_number)