[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Author: pre-commit-ci[bot]

include/proxsuite/proxqp/dense/solver.hpp

@@ -987,8 +987,8 @@ qp_solve( //
 
   T duality_gap(0);
   T rhs_duality_gap(0);
-  isize max_dim = std::max(qpmodel.dim,qpmodel.n_eq);
-  max_dim = std::max(max_dim,qpmodel.n_in);
+  isize max_dim = std::max(qpmodel.dim, qpmodel.n_eq);
+  max_dim = std::max(max_dim, qpmodel.n_in);
   T sqrt_max_dim(std::sqrt(max_dim));
 
   for (i64 iter = 0; iter < qpsettings.max_iter; ++iter) {
@@ -1016,8 +1016,7 @@ qp_solve( //
                          dual_feasibility_rhs_3,
                          rhs_duality_gap,
                          duality_gap,
-                         sqrt_max_dim
-                         );
+                         sqrt_max_dim);
     qpresults.info.pri_res = primal_feasibility_lhs;
     qpresults.info.dua_res = dual_feasibility_lhs;
     qpresults.info.duality_gap = duality_gap;
@@ -1092,7 +1091,8 @@ qp_solve( //
         qpresults.info.rho = rho_new;
       }
       if (is_dual_feasible) {
-        if (qpresults.info.duality_gap<=qpsettings.eps_abs* rhs_duality_gap ){
+        if (qpresults.info.duality_gap <=
+            qpsettings.eps_abs * rhs_duality_gap) {
           qpresults.info.status = QPSolverOutput::PROXQP_SOLVED;
           break;
         }
@@ -1174,7 +1174,8 @@ qp_solve( //
              std::max(dual_feasibility_rhs_1, qpwork.dual_feasibility_rhs_2)));
 
       if (is_dual_feasible) {
-        if (qpresults.info.duality_gap<=qpsettings.eps_abs * rhs_duality_gap ){
+        if (qpresults.info.duality_gap <=
+            qpsettings.eps_abs * rhs_duality_gap) {
           qpresults.info.status = QPSolverOutput::PROXQP_SOLVED;
           break;
         }

include/proxsuite/proxqp/dense/utils.hpp

@@ -372,9 +372,9 @@ global_dual_residual(const Results<T>& qpresults,
   ruiz.unscale_primal_in_place(VectorViewMut<T>{ from_eigen, qpresults.x });
   duality_gap = (qpmodel.g).dot(qpresults.x);
   rhs_duality_gap = std::abs(duality_gap);
-  T xHx = (qpwork.CTz).dot(qpresults.x) ;
-  duality_gap += xHx;// contains now xHx+g.Tx
-  rhs_duality_gap = std::max(rhs_duality_gap,std::abs(xHx));
+  T xHx = (qpwork.CTz).dot(qpresults.x);
+  duality_gap += xHx; // contains now xHx+g.Tx
+  rhs_duality_gap = std::max(rhs_duality_gap, std::abs(xHx));
 
   ruiz.scale_primal_in_place(VectorViewMut<T>{ from_eigen, qpresults.x });
 
@@ -398,24 +398,21 @@ global_dual_residual(const Results<T>& qpresults,
   ruiz.scale_dual_residual_in_place(
     VectorViewMut<T>{ from_eigen, qpwork.dual_residual_scaled });
 
-  ruiz.unscale_dual_in_place_eq(
-    VectorViewMut<T>{ from_eigen, qpresults.y });
+  ruiz.unscale_dual_in_place_eq(VectorViewMut<T>{ from_eigen, qpresults.y });
   T by = (qpmodel.b).dot(qpresults.y);
-  rhs_duality_gap = std::max(rhs_duality_gap,std::abs(by));
+  rhs_duality_gap = std::max(rhs_duality_gap, std::abs(by));
   duality_gap += by;
   ruiz.scale_dual_in_place_eq(VectorViewMut<T>{ from_eigen, qpresults.y });
-  ruiz.unscale_dual_in_place_in(
-    VectorViewMut<T>{ from_eigen, qpresults.z });
-  T zu= positive_part(qpresults.z).dot(qpmodel.u);
-  rhs_duality_gap = std::max(rhs_duality_gap,std::abs(zu));
+  ruiz.unscale_dual_in_place_in(VectorViewMut<T>{ from_eigen, qpresults.z });
+  T zu = positive_part(qpresults.z).dot(qpmodel.u);
+  rhs_duality_gap = std::max(rhs_duality_gap, std::abs(zu));
   duality_gap += zu;
   T zl = negative_part(qpresults.z).dot(qpmodel.l);
-  rhs_duality_gap = std::max(rhs_duality_gap,std::abs(zl));
+  rhs_duality_gap = std::max(rhs_duality_gap, std::abs(zl));
   duality_gap += zl;
-  ruiz.scale_dual_in_place_in(
-    VectorViewMut<T>{ from_eigen, qpresults.z });
+  ruiz.scale_dual_in_place_in(VectorViewMut<T>{ from_eigen, qpresults.z });
   duality_gap /= sqrt_max_dim; // in order to get an a-dimensional duality gap
-  rhs_duality_gap +=1.;
+  rhs_duality_gap += 1.;
 }
 
 } // namespace dense

include/proxsuite/proxqp/sparse/solver.hpp

@@ -725,10 +725,10 @@ qp_solve(Results<T>& results,
     }
   }
   T rhs_duality_gap(0);
-  isize max_dim = std::max(data.dim,data.n_eq);
-  max_dim = std::max(max_dim,data.n_in);
+  isize max_dim = std::max(data.dim, data.n_eq);
+  max_dim = std::max(max_dim, data.n_in);
   T sqrt_max_dim(std::sqrt(max_dim));
-  
+
   for (isize iter = 0; iter < settings.max_iter; ++iter) {
 
     results.info.iter_ext += 1;
@@ -843,7 +843,7 @@ qp_solve(Results<T>& results,
       }
       if (is_primal_feasible(primal_feasibility_lhs) &&
           is_dual_feasible(dual_feasibility_lhs)) {
-          if (results.info.duality_gap<=settings.eps_abs*rhs_duality_gap){
+        if (results.info.duality_gap <= settings.eps_abs * rhs_duality_gap) {
           results.info.pri_res = primal_feasibility_lhs;
           results.info.dua_res = dual_feasibility_lhs;
           results.info.status = QPSolverOutput::PROXQP_SOLVED;
@@ -1235,12 +1235,12 @@ qp_solve(Results<T>& results,
 
       if (is_primal_feasible(primal_feasibility_lhs_new) &&
           is_dual_feasible(dual_feasibility_lhs_new)) {
-          if (results.info.duality_gap<=settings.eps_abs*rhs_duality_gap){
-            results.info.pri_res = primal_feasibility_lhs_new;
-            results.info.dua_res = dual_feasibility_lhs_new;
-            results.info.status = QPSolverOutput::PROXQP_SOLVED;
-            break;
-          }
+        if (results.info.duality_gap <= settings.eps_abs * rhs_duality_gap) {
+          results.info.pri_res = primal_feasibility_lhs_new;
+          results.info.dua_res = dual_feasibility_lhs_new;
+          results.info.status = QPSolverOutput::PROXQP_SOLVED;
+          break;
+        }
       }
 
       // vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv

include/proxsuite/proxqp/sparse/utils.hpp

@@ -649,41 +649,39 @@ unscaled_primal_dual_residual(
     noalias_symhiv_add(tmp, qp_scaled.H.to_eigen(), x_e);
     dual_residual_scaled += tmp;
 
-    precond.unscale_dual_residual_in_place({ proxqp::from_eigen, tmp });// contains unscaled Hx
+    precond.unscale_dual_residual_in_place(
+      { proxqp::from_eigen, tmp }); // contains unscaled Hx
     dual_feasibility_rhs_0 = infty_norm(tmp);
-    precond.unscale_primal_in_place({ proxqp::from_eigen, x_e});
+    precond.unscale_primal_in_place({ proxqp::from_eigen, x_e });
     results.info.duality_gap = x_e.dot(data.g); // contains gTx
     rhs_duality_gap = std::abs(results.info.duality_gap);
-    T xHx = (tmp).dot(x_e) ;
+    T xHx = (tmp).dot(x_e);
     results.info.duality_gap += xHx;
-    rhs_duality_gap = std::max(rhs_duality_gap,std::abs(xHx));
-    tmp += data.g;// contains now Hx+g
-    precond.scale_primal_in_place({ proxqp::from_eigen, x_e});
+    rhs_duality_gap = std::max(rhs_duality_gap, std::abs(xHx));
+    tmp += data.g; // contains now Hx+g
+    precond.scale_primal_in_place({ proxqp::from_eigen, x_e });
 
-    precond.unscale_dual_in_place_eq(
-          { proxsuite::proxqp::from_eigen, y_e });
+    precond.unscale_dual_in_place_eq({ proxsuite::proxqp::from_eigen, y_e });
     T by = (data.b).dot(y_e);
     results.info.duality_gap += by;
-    rhs_duality_gap = std::max(rhs_duality_gap,std::abs(by));
-    precond.scale_dual_in_place_eq(
-          { proxsuite::proxqp::from_eigen, y_e });
-    precond.unscale_dual_in_place_in(
-          { proxsuite::proxqp::from_eigen, z_e });
+    rhs_duality_gap = std::max(rhs_duality_gap, std::abs(by));
+    precond.scale_dual_in_place_eq({ proxsuite::proxqp::from_eigen, y_e });
+    precond.unscale_dual_in_place_in({ proxsuite::proxqp::from_eigen, z_e });
     T zl = (data.l).dot(detail::negative_part(z_e));
     results.info.duality_gap += zl;
-    rhs_duality_gap = std::max(rhs_duality_gap,std::abs(zl));
+    rhs_duality_gap = std::max(rhs_duality_gap, std::abs(zl));
     T zu = (data.u).dot(detail::positive_part(z_e));
     results.info.duality_gap += zu;
-    rhs_duality_gap = std::max(rhs_duality_gap,std::abs(zu));
-    precond.scale_dual_in_place_in(
-          { proxsuite::proxqp::from_eigen, z_e });
-    results.info.duality_gap /= sqrt_max_dim; // in order to get an a-dimensional duality gap
-    rhs_duality_gap +=1.;
+    rhs_duality_gap = std::max(rhs_duality_gap, std::abs(zu));
+    precond.scale_dual_in_place_in({ proxsuite::proxqp::from_eigen, z_e });
+    results.info.duality_gap /=
+      sqrt_max_dim; // in order to get an a-dimensional duality gap
+    rhs_duality_gap += 1.;
   }
 
   {
     auto ATy = tmp;
-    ATy.setZero(); 
+    ATy.setZero();
     primal_residual_eq_scaled.setZero();
 
     detail::noalias_gevmmv_add(
@@ -693,7 +691,6 @@ unscaled_primal_dual_residual(
 
     precond.unscale_dual_residual_in_place({ proxqp::from_eigen, ATy });
     dual_feasibility_rhs_1 = infty_norm(ATy);
-
   }
 
   {