casadi 3.6.7__cp312-none-macosx_11_0_arm64.whl → 3.7.1__cp312-none-macosx_11_0_arm64.whl

casadi/include/highs/qpsolver/feasibility_bounded.hpp

@@ -5,13 +5,13 @@
 #include "qpsolver/a_asm.hpp"
 #include "qpsolver/crashsolution.hpp"
 
-static void computeStartingPointBounded(Instance& instance,
-					Settings& settings,
-					Statistics& stats,
-					QpModelStatus& modelstatus,
-					QpHotstartInformation& result,
-					HighsTimer& timer) {
-  // compute initial feasible point for problems with bounds only (no general linear constraints)
+static void computeStartingPointBounded(Instance& instance, Settings& settings,
+                                        Statistics& stats,
+                                        QpModelStatus& modelstatus,
+                                        QpHotstartInformation& result,
+                                        HighsTimer& timer) {
+  // compute initial feasible point for problems with bounds only (no general
+  // linear constraints)
 
   // compute  Qx + c = 0 --> x = Q^-1c
   std::vector<double> L;
@@ -19,16 +19,18 @@ static void computeStartingPointBounded(Instance& instance,
 
   // compute cholesky factorization of Q
   for (size_t col = 0; col < (size_t)instance.num_var; col++) {
-    for (size_t idx = instance.Q.mat.start[col]; idx < (size_t)instance.Q.mat.start[col+1]; idx++) {
+    for (size_t idx = instance.Q.mat.start[col];
+         idx < (size_t)instance.Q.mat.start[col + 1]; idx++) {
       double sum = 0;
-      size_t row = instance.Q.mat.index[idx]; 
+      size_t row = instance.Q.mat.index[idx];
       if (row == col) {
         for (size_t k = 0; k < row; k++)
           sum += L[k * instance.num_var + row] * L[k * instance.num_var + row];
         L[row * instance.num_var + row] = sqrt(instance.Q.mat.value[idx] - sum);
       } else {
         for (size_t k = 0; k < row; k++)
-          sum += (L[k * instance.num_var + col] * L[k * instance.num_var + row]);
+          sum +=
+              (L[k * instance.num_var + col] * L[k * instance.num_var + row]);
         L[row * instance.num_var + col] =
             (instance.Q.mat.value[idx] - sum) / L[row * instance.num_var + row];
       }
@@ -37,7 +39,7 @@ static void computeStartingPointBounded(Instance& instance,
 
   // solve for c
   QpVector res = -instance.c;
-  for (HighsInt r = 0; r <res.dim; r++) {
+  for (HighsInt r = 0; r < res.dim; r++) {
     for (HighsInt j = 0; j < r; j++) {
       res.value[r] -= res.value[j] * L[j * instance.num_var + r];
     }
@@ -59,27 +61,27 @@ static void computeStartingPointBounded(Instance& instance,
   std::vector<HighsInt> initialinactive;
   std::vector<BasisStatus> atlower;
 
-  for (int i=0; i<instance.num_var; i++) {
-    if (res.value[i] > 0.5/settings.hessianregularizationfactor 
-        && instance.var_up[i] == std::numeric_limits<double>::infinity()
-        && instance.c.value[i] < 0.0) {
-          modelstatus = QpModelStatus::kUnbounded;
-          return;
-    } else if (res.value[i] < 0.5/settings.hessianregularizationfactor 
-        && instance.var_lo[i] == std::numeric_limits<double>::infinity()
-        && instance.c.value[i] > 0.0) {
-          modelstatus = QpModelStatus::kUnbounded;
-          return;
+  for (int i = 0; i < instance.num_var; i++) {
+    if (res.value[i] > 0.5 / settings.hessianregularizationfactor &&
+        instance.var_up[i] == std::numeric_limits<double>::infinity() &&
+        instance.c.value[i] < 0.0) {
+      modelstatus = QpModelStatus::kUnbounded;
+      return;
+    } else if (res.value[i] < 0.5 / settings.hessianregularizationfactor &&
+               instance.var_lo[i] == std::numeric_limits<double>::infinity() &&
+               instance.c.value[i] > 0.0) {
+      modelstatus = QpModelStatus::kUnbounded;
+      return;
     } else if (res.value[i] <= instance.var_lo[i]) {
-        res.value[i] = instance.var_lo[i];
-        initialactive.push_back(i + instance.num_con);
-        atlower.push_back(BasisStatus::kActiveAtLower);
+      res.value[i] = instance.var_lo[i];
+      initialactive.push_back(i + instance.num_con);
+      atlower.push_back(BasisStatus::kActiveAtLower);
     } else if (res.value[i] >= instance.var_up[i]) {
-        res.value[i] = instance.var_up[i];
-        initialactive.push_back(i + instance.num_con);
-        atlower.push_back(BasisStatus::kActiveAtUpper);
+      res.value[i] = instance.var_up[i];
+      initialactive.push_back(i + instance.num_con);
+      atlower.push_back(BasisStatus::kActiveAtUpper);
     } else {
-        initialinactive.push_back(i + instance.num_con);
+      initialinactive.push_back(i + instance.num_con);
     }
     if (fabs(res.value[i]) > 1e-4) {
       x0.value[i] = res.value[i];

casadi/include/highs/qpsolver/feasibility_highs.hpp

@@ -5,15 +5,11 @@
 #include "qpsolver/a_asm.hpp"
 #include "qpsolver/crashsolution.hpp"
 
-static void computeStartingPointHighs(Instance& instance,
-				      Settings& settings,
-				      Statistics& stats,
-				      QpModelStatus& modelstatus,
-				      QpHotstartInformation& result,
-				      HighsModelStatus& highs_model_status,
-				      HighsBasis& highs_basis,
-				      HighsSolution& highs_solution,
-				      HighsTimer& timer) {
+static void computeStartingPointHighs(
+    Instance& instance, Settings& settings, Statistics& stats,
+    QpModelStatus& modelstatus, QpHotstartInformation& result,
+    HighsModelStatus& highs_model_status, HighsBasis& highs_basis,
+    HighsSolution& highs_solution, HighsTimer& timer) {
   bool have_starting_point = false;
   const bool debug_report = false;
   if (highs_solution.value_valid) {
@@ -28,24 +24,26 @@ static void computeStartingPointHighs(Instance& instance,
     double sum_con_infeasibilities = 0;
     double max_con_residual = 0;
     double sum_con_residuals = 0;
-     
-    assessQpPrimalFeasibility(instance, primal_feasibility_tolerance,
-			      highs_solution.col_value, highs_solution.row_value,
-			      num_var_infeasibilities, max_var_infeasibility, sum_var_infeasibilities,
-			      num_con_infeasibilities, max_con_infeasibility, sum_con_infeasibilities,
-			      max_con_residual, sum_con_residuals);
 
-    if (debug_report) printf("computeStartingPointHighs highs_solution has (num / max / sum) "
-	   "var (%d / %g / %g) and "
-	   "con (%d / %g / %g) infeasibilities "
-	   "with (max = %g; sum = %g) residuals\n",
-	   int(num_var_infeasibilities), max_var_infeasibility, sum_var_infeasibilities,
-	   int(num_con_infeasibilities), max_con_infeasibility, sum_con_infeasibilities,
-	   max_con_residual, sum_con_residuals);
-    have_starting_point = 
-      num_var_infeasibilities == 0 &&
-      num_con_infeasibilities == 0 &&
-      highs_basis.valid;
+    assessQpPrimalFeasibility(
+        instance, primal_feasibility_tolerance, highs_solution.col_value,
+        highs_solution.row_value, num_var_infeasibilities,
+        max_var_infeasibility, sum_var_infeasibilities, num_con_infeasibilities,
+        max_con_infeasibility, sum_con_infeasibilities, max_con_residual,
+        sum_con_residuals);
+
+    if (debug_report)
+      printf(
+          "computeStartingPointHighs highs_solution has (num / max / sum) "
+          "var (%d / %g / %g) and "
+          "con (%d / %g / %g) infeasibilities "
+          "with (max = %g; sum = %g) residuals\n",
+          int(num_var_infeasibilities), max_var_infeasibility,
+          sum_var_infeasibilities, int(num_con_infeasibilities),
+          max_con_infeasibility, sum_con_infeasibilities, max_con_residual,
+          sum_con_residuals);
+    have_starting_point = num_var_infeasibilities == 0 &&
+                          num_con_infeasibilities == 0 && highs_basis.valid;
   }
   // compute initial feasible point
   HighsBasis use_basis;
@@ -53,16 +51,18 @@ static void computeStartingPointHighs(Instance& instance,
   if (have_starting_point) {
     use_basis = highs_basis;
     use_solution = highs_solution;
+    // Have to assume that the supplied basis is feasible
+    modelstatus = QpModelStatus::kNotset;
   } else {
     Highs highs;
 
     // set HiGHS to be silent
     highs.setOptionValue("output_flag", false);
-
-    highs.setOptionValue("presolve", "on");
-
-    highs.setOptionValue("time_limit", settings.time_limit -
-			 timer.readRunHighsClock());
+    highs.setOptionValue("presolve", kHighsOnString);
+    // Set the residual time limit
+    const double use_time_limit =
+        std::max(settings.time_limit - timer.read(), 0.001);
+    highs.setOptionValue("time_limit", use_time_limit);
 
     HighsLp lp;
     lp.a_matrix_.index_ = instance.A.mat.index;
@@ -81,11 +81,11 @@ static void computeStartingPointHighs(Instance& instance,
     // create artificial bounds for free variables: false by default
     assert(!settings.phase1boundfreevars);
     if (settings.phase1boundfreevars) {
-      for (HighsInt i=0; i<instance.num_var; i++) {
-	if (isfreevar(instance, i)) {
-	  lp.col_lower_[i] = -1E5;
-	  lp.col_upper_[i] = 1E5;
-	}
+      for (HighsInt i = 0; i < instance.num_var; i++) {
+        if (isfreevar(instance, i)) {
+          lp.col_lower_[i] = -1E5;
+          lp.col_upper_[i] = 1E5;
+        }
       }
     }
 
@@ -96,18 +96,18 @@ static void computeStartingPointHighs(Instance& instance,
       HighsBasis basis;
       basis.alien = true;  // Set true when basis is instantiated
       for (HighsInt i = 0; i < instance.num_con; i++) {
-	basis.row_status.push_back(HighsBasisStatus::kNonbasic);
+        basis.row_status.push_back(HighsBasisStatus::kNonbasic);
       }
 
       for (HighsInt i = 0; i < instance.num_var; i++) {
-	// make free variables basic
-	if (instance.var_lo[i] == -kHighsInf &&
-	    instance.var_up[i] == kHighsInf) {
-	  // free variable
-	  basis.col_status.push_back(HighsBasisStatus::kBasic);
-	} else {
-	  basis.col_status.push_back(HighsBasisStatus::kNonbasic);
-	}
+        // make free variables basic
+        if (instance.var_lo[i] == -kHighsInf &&
+            instance.var_up[i] == kHighsInf) {
+          // free variable
+          basis.col_status.push_back(HighsBasisStatus::kBasic);
+        } else {
+          basis.col_status.push_back(HighsBasisStatus::kNonbasic);
+        }
       }
 
       highs.setBasis(basis);
@@ -116,19 +116,37 @@ static void computeStartingPointHighs(Instance& instance,
     }
 
     HighsStatus status = highs.run();
-    if (status != HighsStatus::kOk) {
+    if (status == HighsStatus::kError) {
       modelstatus = QpModelStatus::kError;
       return;
     }
 
-    stats.phase1_iterations = highs.getInfo().simplex_iteration_count;
-
     HighsModelStatus phase1stat = highs.getModelStatus();
-    if (phase1stat == HighsModelStatus::kInfeasible) {
-      modelstatus = QpModelStatus::kInfeasible;
-      return;
+    switch (phase1stat) {
+      case HighsModelStatus::kOptimal:
+        modelstatus = QpModelStatus::kNotset;
+        break;
+      case HighsModelStatus::kInfeasible:
+        modelstatus = QpModelStatus::kInfeasible;
+        break;
+      case HighsModelStatus::kTimeLimit:
+        modelstatus = QpModelStatus::kTimeLimit;
+        break;
+      case HighsModelStatus::kInterrupt:
+        modelstatus = QpModelStatus::kInterrupt;
+        break;
+      default:
+        modelstatus = QpModelStatus::kError;
     }
 
+    stats.phase1_iterations = highs.getInfo().simplex_iteration_count;
+
+    if (modelstatus != QpModelStatus::kNotset) return;
+
+    // Should only get here if feasibility problem is solved to
+    // optimality - hence there is a feasible basis
+    assert(phase1stat == HighsModelStatus::kOptimal);
+
     use_basis = highs.getBasis();
     use_solution = highs.getSolution();
   }
@@ -155,14 +173,16 @@ static void computeStartingPointHighs(Instance& instance,
       num_small_ra++;
     }
   }
-  if (debug_report && num_small_x0+num_small_ra)
-    printf("feasibility_highs has %d small col values and %d small row values\n",
-	   int(num_small_x0), int(num_small_ra));
+  if (debug_report && num_small_x0 + num_small_ra)
+    printf(
+        "feasibility_highs has %d small col values and %d small row values\n",
+        int(num_small_x0), int(num_small_ra));
   std::vector<HighsInt> initial_active;
   std::vector<HighsInt> initial_inactive;
   std::vector<BasisStatus> initial_status;
 
-  const HighsInt num_highs_basis_status = HighsInt(HighsBasisStatus::kNonbasic)+1;
+  const HighsInt num_highs_basis_status =
+      HighsInt(HighsBasisStatus::kNonbasic) + 1;
   std::vector<HighsInt> debug_row_status_count;
   debug_row_status_count.assign(num_highs_basis_status, 0);
   for (HighsInt i = 0; i < HighsInt(use_basis.row_status.size()); i++) {
@@ -178,7 +198,7 @@ static void computeStartingPointHighs(Instance& instance,
       // Shouldn't happen, since free rows are basic in a logical
       // basis and remain basic, or are removed by presolve and
       // restored as basic in postsolve
-      assert(111==222);
+      assert(111 == 222);
       // That said, a free row that is nonbasic in the Highs basis
       // must be counted as inactive in the QP basis for accounting
       // purposes
@@ -212,7 +232,7 @@ static void computeStartingPointHighs(Instance& instance,
         initial_active.push_back(instance.num_con + i);
         initial_status.push_back(BasisStatus::kActiveAtLower);
       }
-      
+
     } else if (status == HighsBasisStatus::kUpper) {
       if (isfreevar(instance, i)) {
         initial_inactive.push_back(instance.num_con + i);
@@ -220,7 +240,7 @@ static void computeStartingPointHighs(Instance& instance,
         initial_active.push_back(instance.num_con + i);
         initial_status.push_back(BasisStatus::kActiveAtUpper);
       }
-      
+
     } else if (status == HighsBasisStatus::kZero) {
       initial_inactive.push_back(instance.num_con + i);
     } else if (status != HighsBasisStatus::kBasic) {
@@ -233,29 +253,33 @@ static void computeStartingPointHighs(Instance& instance,
 
   if (debug_report) {
     printf("QP solver initial basis: (Lo / Bs / Up / Ze / Nb) for cols (");
-    for (HighsInt k = 0; k < num_highs_basis_status; k++) 
-      printf("%s%d", k==0 ? "" : " / ", int(debug_col_status_count[k]));
+    for (HighsInt k = 0; k < num_highs_basis_status; k++)
+      printf("%s%d", k == 0 ? "" : " / ", int(debug_col_status_count[k]));
     printf(") and rows (");
-    for (HighsInt k = 0; k < num_highs_basis_status; k++) 
-      printf("%s%d", k==0 ? "" : " / ", int(debug_row_status_count[k]));
+    for (HighsInt k = 0; k < num_highs_basis_status; k++)
+      printf("%s%d", k == 0 ? "" : " / ", int(debug_row_status_count[k]));
     printf(")\n");
   }
 
-  assert((HighsInt)(initial_active.size() + initial_inactive.size()) ==
-	 instance.num_var);
+  // This used to be an assert
+  if ((HighsInt)(initial_active.size() + initial_inactive.size()) !=
+      instance.num_var) {
+    modelstatus = QpModelStatus::kError;
+    return;
+  }
 
   if (!have_starting_point) {
     // When starting from a feasible basis, there will generally be
     // inactive variables in the basis that aren't free
     for (HighsInt ia : initial_inactive) {
       if (ia < instance.num_con) {
-	// printf("free row %d\n", (int)ia);
-	assert(instance.con_lo[ia] == -kHighsInf);
-	assert(instance.con_up[ia] == kHighsInf);
+        // printf("free row %d\n", (int)ia);
+        assert(instance.con_lo[ia] == -kHighsInf);
+        assert(instance.con_up[ia] == kHighsInf);
       } else {
-	// printf("free col %d\n", (int)ia);
-	assert(instance.var_lo[ia - instance.num_con] == -kHighsInf);
-	assert(instance.var_up[ia - instance.num_con] == kHighsInf);
+        // printf("free col %d\n", (int)ia);
+        assert(instance.var_lo[ia - instance.num_con] == -kHighsInf);
+        assert(instance.var_up[ia - instance.num_con] == kHighsInf);
       }
     }
   }

casadi/include/highs/qpsolver/gradient.hpp

@@ -1,8 +1,8 @@
 #ifndef __SRC_LIB_GRADIENT_HPP__
 #define __SRC_LIB_GRADIENT_HPP__
 
-#include "runtime.hpp"
 #include "qpvector.hpp"
+#include "runtime.hpp"
 
 class Gradient {
   Runtime& runtime;

casadi/include/highs/qpsolver/instance.hpp

@@ -12,7 +12,7 @@ struct SumNum {
 };
 
 struct Instance {
-  HighsInt sense = 1; // Minimization
+  HighsInt sense = 1;  // Minimization
   HighsInt num_var = 0;
   HighsInt num_con = 0;
   double offset = 0;

casadi/include/highs/qpsolver/pricing.hpp

@@ -6,8 +6,8 @@
 class Pricing {
  public:
   virtual HighsInt price(const QpVector& x, const QpVector& gradient) = 0;
-  virtual void update_weights(const QpVector& aq, const QpVector& ep, HighsInt p,
-                              HighsInt q) = 0;
+  virtual void update_weights(const QpVector& aq, const QpVector& ep,
+                              HighsInt p, HighsInt q) = 0;
   virtual void recompute() = 0;
   virtual ~Pricing() {}
 };

casadi/include/highs/qpsolver/qpconst.hpp

@@ -5,7 +5,7 @@
 enum class QpSolverStatus { OK, NOTPOSITIVDEFINITE, DEGENERATE };
 
 enum class QpModelStatus {
-  kNotset, // 0
+  kNotset,  // 0
   kUndetermined,
   kOptimal,
   kUnbounded,
@@ -13,6 +13,7 @@ enum class QpModelStatus {
   kIterationLimit,
   kTimeLimit,
   kLargeNullspace,
+  kInterrupt,
   kError
 };
 
@@ -23,5 +24,4 @@ enum class BasisStatus {
   kInactiveInBasis
 };
 
-
 #endif

casadi/include/highs/qpsolver/quass.hpp

@@ -10,11 +10,11 @@
 struct Quass {
   Quass(Runtime& rt);
 
-  void solve(const QpVector& x0, const QpVector& ra, Basis& b0, HighsTimer& timer);
+  void solve(const QpVector& x0, const QpVector& ra, Basis& b0,
+             HighsTimer& timer);
 
  private:
   Runtime& runtime;
-
 };
 
 #endif

casadi/include/highs/qpsolver/runtime.hpp

@@ -1,11 +1,11 @@
 #ifndef __SRC_LIB_RUNTIME_HPP__
 #define __SRC_LIB_RUNTIME_HPP__
 
-#include "util/HighsTimer.h"
 #include "instance.hpp"
+#include "qpsolver/qpconst.hpp"
 #include "settings.hpp"
 #include "statistics.hpp"
-#include "qpsolver/qpconst.hpp"
+#include "util/HighsTimer.h"
 
 struct Runtime {
   Instance instance;

casadi/include/highs/qpsolver/settings.hpp

@@ -18,14 +18,26 @@ struct Settings {
 
   PricingStrategy pricing = PricingStrategy::Devex;
 
-  double pnorm_zero_threshold = 1e-11; // if ||p|| < this threshold, p is determined to not be an improving search direction
-  double improvement_zero_threshold = 1e-4; // if p^t gradient < this threshold, p is determined to not be an improving search direction
-  double d_zero_threshold = 1e-12; // minimal value for pivot, will declare degeneracy if no larger pivot is found
-  double lambda_zero_threshold = 1e-9; // used for pricing / optimality checking
-  double pQp_zero_threshold = 1e-7; // if p'Qp < this, p is determined to not have curvature, a simplex-like iteration is performed.
+  double pnorm_zero_threshold =
+      1e-11;  // if ||p|| < this threshold, p is determined to not be an
+              // improving search direction
+  double improvement_zero_threshold =
+      1e-4;  // if p^t gradient < this threshold, p is determined to not be an
+             // improving search direction
+  double d_zero_threshold = 1e-12;  // minimal value for pivot, will declare
+                                    // degeneracy if no larger pivot is found
+  double lambda_zero_threshold =
+      1e-9;  // used for pricing / optimality checking
+  double pQp_zero_threshold =
+      1e-7;  // if p'Qp < this, p is determined to not have curvature, a
+             // simplex-like iteration is performed.
 
-  bool hessianregularization = false; // if true, a small multiple of the identity matrix will be added to the Hessian
-  double hessianregularizationfactor = 1e-7; // multiple of identity matrix added to hessian in case of regularization
+  bool hessianregularization =
+      false;  // if true, a small multiple of the identity matrix will be added
+              // to the Hessian
+  double hessianregularizationfactor =
+      1e-7;  // multiple of identity matrix added to hessian in case of
+             // regularization
 
   Phase1Strategy phase1strategy = Phase1Strategy::HIGHS;
   bool phase1movefreevarsbasic = false;
@@ -37,7 +49,7 @@ struct Settings {
   Eventhandler<HighsInt&> nullspace_limit_log;
 
   HighsInt nullspace_limit = 4000;
-  
+
   HighsInt reinvertfrequency = 1000;
   HighsInt gradientrecomputefrequency = 100;
   HighsInt reducedgradientrecomputefrequency =

casadi/include/highs/qpsolver/steepestedgepricing.hpp

@@ -57,22 +57,21 @@ class SteepestEdgePricing : public Pricing {
         basis(bas),
         redcosts(rc),
         weights(std::vector<double>(rt.instance.num_var, 1.0)) {
-          compute_exact_weights();
-        };
+    compute_exact_weights();
+  };
 
   HighsInt price(const QpVector& x, const QpVector& gradient) {
     HighsInt minidx = chooseconstrainttodrop(redcosts.getReducedCosts());
     return minidx;
   }
 
-
   double compute_exact_weight(HighsInt i) {
     QpVector y_i = basis.btran(QpVector::unit(runtime.instance.num_var, i));
     return y_i.dot(y_i);
   }
 
   void compute_exact_weights() {
-    for (int i=0; i<runtime.instance.num_var; i++) {
+    for (int i = 0; i < runtime.instance.num_var; i++) {
       weights[i] = compute_exact_weight(i);
     }
   }
@@ -80,24 +79,24 @@ class SteepestEdgePricing : public Pricing {
   bool check_weight(HighsInt i) {
     double weight_is = weights[i];
     double weight_comp = compute_exact_weight(i);
-    if(fabs(weight_comp - weight_is) > 1e-2) {
-      //printf("weights[%d] = %lf, should be %lf\n", i, weight_is, weight_comp);
+    if (fabs(weight_comp - weight_is) > 1e-2) {
+      // printf("weights[%d] = %lf, should be %lf\n", i, weight_is,
+      // weight_comp);
       return false;
     }
     return true;
   }
 
   bool check_weights() {
-
     std::vector<int> correct_weights;
     std::vector<int> incorrect_weights;
-    for (int i=0; i<runtime.instance.num_var; i++) {
+    for (int i = 0; i < runtime.instance.num_var; i++) {
       bool correct = check_weight(i);
-        if (correct) {
-          correct_weights.push_back(i);
-        } else {
-          incorrect_weights.push_back(i);
-        }
+      if (correct) {
+        correct_weights.push_back(i);
+      } else {
+        incorrect_weights.push_back(i);
+      }
     }
 
     printf("correct weights: ");
@@ -113,53 +112,53 @@ class SteepestEdgePricing : public Pricing {
     printf("\n");
 
     return incorrect_weights.size() == 0;
-    }
-
-  void recompute() {
-    compute_exact_weights();
   }
 
+  void recompute() { compute_exact_weights(); }
+
   void update_weights(const QpVector& aq, const QpVector& ep, HighsInt p,
                       HighsInt q) {
     HighsInt rowindex_p = basis.getindexinfactor()[p];
-    //printf("Update weights, p = %d, rowindex = %d, q = %d\n", p, rowindex_p, q);
+    // printf("Update weights, p = %d, rowindex = %d, q = %d\n", p, rowindex_p,
+    // q);
 
-    //if (!check_weights()) {
-    //  printf("weight check failed\n");
-    //  exit(1);
-    //}
+    // if (!check_weights()) {
+    //   printf("weight check failed\n");
+    //   exit(1);
+    // }
 
     QpVector delta = basis.ftran(aq);
 
-    //double old_weight_p_updated = weights[rowindex_p];
-    // exact weight coming in needs to come in before update.
+    // double old_weight_p_updated = weights[rowindex_p];
+    //  exact weight coming in needs to come in before update.
     double old_weight_p_computed = ep.dot(ep);
 
-    //if (fabs(old_weight_p_computed - old_weight_p_updated) >= 1e-2) {
-    //  printf("old weight[p] discrepancy: updated = %lf, computed=%lf\n", old_weight_p_updated, old_weight_p_computed);
-    //}
+    // if (fabs(old_weight_p_computed - old_weight_p_updated) >= 1e-2) {
+    //   printf("old weight[p] discrepancy: updated = %lf, computed=%lf\n",
+    //   old_weight_p_updated, old_weight_p_computed);
+    // }
 
     double weight_p = old_weight_p_computed;
 
-    
     double t_p = aq.value[rowindex_p];
     for (HighsInt i = 0; i < runtime.instance.num_var; i++) {
       if (i != rowindex_p) {
         double t_i = aq.value[i];
-        weights[i] = weights[i]
-                    - 2 * (t_i / t_p) * delta.value[i]
-                    + ((t_i * t_i) / (t_p * t_p)) * weight_p;
-        //printf("weights[%d] = %lf\n", i, weights[i]);
+        weights[i] = weights[i] - 2 * (t_i / t_p) * delta.value[i] +
+                     ((t_i * t_i) / (t_p * t_p)) * weight_p;
+        // printf("weights[%d] = %lf\n", i, weights[i]);
       }
     }
-    //QpVector new_ep = basis.btran(QpVector::unit(runtime.instance.num_var, rowindex_p)); 
-    //double computed_weight = new_ep.dot(new_ep);
+    // QpVector new_ep = basis.btran(QpVector::unit(runtime.instance.num_var,
+    // rowindex_p)); double computed_weight = new_ep.dot(new_ep);
     double new_weight_p_updated = weight_p / (t_p * t_p);
-    
-    //if (fabs(updated_weight - computed_weight) > 1e-4) {
-    //  printf("updated weight %lf vs computed weight %lf. aq[p] = %lf\n", updated_weight, computed_weight, t_p);
-    //  printf("old weight = %lf, aq[p] = %lf, ^2 = %lf, new weight = %lf\n", weight_p, t_p, t_p*t_p, updated_weight);
-    //}
+
+    // if (fabs(updated_weight - computed_weight) > 1e-4) {
+    //   printf("updated weight %lf vs computed weight %lf. aq[p] = %lf\n",
+    //   updated_weight, computed_weight, t_p); printf("old weight = %lf, aq[p]
+    //   = %lf, ^2 = %lf, new weight = %lf\n", weight_p, t_p, t_p*t_p,
+    //   updated_weight);
+    // }
     weights[rowindex_p] = new_weight_p_updated;
   }
 };