Added code so VScode breakpoint can be used before solving the LP relaxation that yields nonbasic variable off its bound

Author: jajhall

highs/lp_data/HighsInterface.cpp

@@ -2897,13 +2897,15 @@ HighsStatus Highs::lpKktCheck(const HighsLp& lp, const std::string& message) {
             info.max_relative_dual_residual_error, dual_residual_tolerance);
       }
       if (info.num_complementarity_violations) {
-	if (!this->options_.output_flag) {
-	  printf("Highs::lpKktCheck With basis num_complementarity_violations = %d\n",
-		 int(info.num_complementarity_violations));
-	  this->options_.output_flag = true;
-	  this->writeSolution("", 1);
-	  this->lpKktCheck(lp, message);
-	}
+        if (!this->options_.output_flag) {
+          printf(
+              "Highs::lpKktCheck With basis num_complementarity_violations = "
+              "%d\n",
+              int(info.num_complementarity_violations));
+          this->options_.output_flag = true;
+          this->writeSolution("", 1);
+          this->lpKktCheck(lp, message);
+        }
       }
       assert(info.num_complementarity_violations == 0);
       assert(info.primal_dual_objective_error <= optimality_tolerance);

highs/lp_data/HighsSolution.cpp

@@ -54,8 +54,8 @@ void getLpKktFailures(const HighsOptions& options, const HighsLp& lp,
                       const HighsSolution& solution, const HighsBasis& basis,
                       HighsInfo& highs_info) {
   HighsPrimalDualErrors primal_dual_errors;
-  getLpKktFailures(options, lp, solution, basis, highs_info,
-                   primal_dual_errors, false);
+  getLpKktFailures(options, lp, solution, basis, highs_info, primal_dual_errors,
+                   false);
 }
 
 void getLpKktFailures(const HighsOptions& options, const HighsLp& lp,
@@ -73,8 +73,7 @@ void getLpKktFailures(const HighsOptions& options, const HighsLp& lp,
 void getKktFailures(const HighsOptions& options, const bool is_qp,
                     const HighsLp& lp, const std::vector<double>& gradient,
                     const HighsSolution& solution, HighsInfo& highs_info,
-                    const bool get_residuals,
-		    const bool basic_solution) {
+                    const bool get_residuals, const bool basic_solution) {
   double primal_feasibility_tolerance = options.primal_feasibility_tolerance;
   double dual_feasibility_tolerance = options.dual_feasibility_tolerance;
   double primal_residual_tolerance = options.primal_residual_tolerance;
@@ -957,7 +956,7 @@ bool getComplementarityViolations(const HighsLp& lp,
                                   const double optimality_tolerance,
                                   HighsInt& num_complementarity_violation,
                                   double& max_complementarity_violation,
-				  const bool basic_solution) {
+                                  const bool basic_solution) {
   num_complementarity_violation = kHighsIllegalComplementarityCount;
   max_complementarity_violation = kHighsIllegalComplementarityViolation;
   if (!solution.dual_valid) return false;
@@ -986,11 +985,11 @@ bool getComplementarityViolations(const HighsLp& lp,
     const double complementarity_violation = primal_residual * dual_residual;
     if (complementarity_violation > optimality_tolerance) {
       if (basic_solution) {
-	printf("getComplementarityViolations: %s %d has (primal / dual) residual (%g / %g) violation = %g\n",
-	       is_col ? "column" : "row",
-	       is_col ? int(iVar) : int(iRow),
-	       primal_residual, dual_residual,
-	       complementarity_violation);
+        printf(
+            "getComplementarityViolations: %s %d has (primal / dual) residual "
+            "(%g / %g) violation = %g\n",
+            is_col ? "column" : "row", is_col ? int(iVar) : int(iRow),
+            primal_residual, dual_residual, complementarity_violation);
       }
       num_complementarity_violation++;
     }

highs/lp_data/HighsSolution.h

@@ -82,8 +82,8 @@ void getLpKktFailures(const HighsOptions& options, const HighsLp& lp,
 void getKktFailures(const HighsOptions& options, const bool is_qp,
                     const HighsLp& lp, const std::vector<double>& gradient,
                     const HighsSolution& solution, HighsInfo& highs_info,
-                    const bool get_residuals,// = false,
-		    const bool basic_solution = false);
+                    const bool get_residuals,  // = false,
+                    const bool basic_solution = false);
 
 void getVariableKktFailures(const double primal_feasibility_tolerance,
                             const double dual_feasibility_tolerance,
@@ -109,7 +109,7 @@ bool getComplementarityViolations(const HighsLp& lp,
                                   const double optimality_tolerance,
                                   HighsInt& num_complementarity_violations,
                                   double& max_complementarity_violation,
-				  const bool basic_solution = false);
+                                  const bool basic_solution = false);
 
 bool computeDualObjectiveValue(const HighsModel& model,
                                const HighsSolution& solution,

highs/mip/HighsLpRelaxation.cpp

@@ -1153,18 +1153,19 @@ HighsLpRelaxation::Status HighsLpRelaxation::run(bool resolve_on_error) {
   }
   if (use_simplex) {
     const HighsLp& lp = lpsolver.getLp();
-    const bool check_lp = lp.num_col_ == 9 && lp.num_row_ == 23 && lp.a_matrix_.numNz() == 200;
+    const bool check_lp = this->numSolved == 8 && lp.num_col_ == 9 &&
+                          lp.num_row_ == 23 && lp.a_matrix_.numNz() == 200;
     if (check_lp) {
       printf("HighsLpRelaxation::run Checking solution of LP\n");
       lpsolver.setOptionValue("output_flag", true);
-      lpsolver.setOptionValue("log_dev_level", 3);
-      lpsolver.setOptionValue("highs_analysis_level", 4);
-    }      
+      lpsolver.setOptionValue("log_dev_level", 1);  // 3);
+      //      lpsolver.setOptionValue("highs_analysis_level", 4);
+    }
     callstatus = lpsolver.run();
     if (check_lp) {
       lpsolver.setOptionValue("output_flag", false);
       lpsolver.setOptionValue("log_dev_level", 0);
-    }      
+    }
   }
   // Revert the value of lpsolver.options_.solver
   lpsolver.setOptionValue("solver", solver);