Merge pull request #12 from Simple-Robotics/pre-commit-ci-update-config

jorisv · web-flow · commit fd32d6180b0f · 2025-04-14T15:02:28.000+02:00
[pre-commit.ci] pre-commit autoupdate
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
@@ -4,7 +4,7 @@ ci:
   autoupdate_schedule: quarterly
 repos:
   - repo: https://github.com/pre-commit/mirrors-clang-format
-    rev: v19.1.6
+    rev: v20.1.0
     hooks:
       - id: clang-format
         types_or: []
diff --git a/include/loik/ik-id-description-optimized.hpp b/include/loik/ik-id-description-optimized.hpp
@@ -37,15 +37,16 @@ namespace loik
     {
       if (nj_ != nb_ + 1)
       {
-        throw(std::runtime_error("[IkProblemFormulation::IkProblemFormulation]: nb does not equal "
-                                 "to nj - 1, robot model not supported !!!"));
+        throw(std::runtime_error(
+          "[IkProblemFormulation::IkProblemFormulation]: nb does not equal "
+          "to nj - 1, robot model not supported !!!"));
       }
 
       if (eq_c_dim != 6)
       {
-        throw(
-          std::runtime_error("[IkProblemFormulation::IkProblemFormulation]: equality constraint "
-                             "dimension is not 6, problem formulation not supported !!!"));
+        throw(std::runtime_error(
+          "[IkProblemFormulation::IkProblemFormulation]: equality constraint "
+          "dimension is not 6, problem formulation not supported !!!"));
       }
 
       H_refs_.reserve(static_cast<std::size_t>(nj));
@@ -112,8 +113,9 @@ namespace loik
         H_refs.size() != static_cast<std::size_t>(nj_)
         || v_refs.size() != static_cast<std::size_t>(nj_))
       {
-        throw(std::runtime_error("[IkProblemFormulation::UpdateReferences]: input arguments "
-                                 "'H_refs', 'v_refs' have wrong size!!"));
+        throw(std::runtime_error(
+          "[IkProblemFormulation::UpdateReferences]: input arguments "
+          "'H_refs', 'v_refs' have wrong size!!"));
       }
       H_refs_ = H_refs;
       v_refs_ = v_refs;
@@ -144,8 +146,9 @@ namespace loik
       // check constraint specification is consistant
       if (!((active_task_constraint_ids.size() == Ais.size()) && ((Ais.size() == bis.size()))))
       {
-        throw(std::runtime_error("[IkProblemFormulation::UpdateEqConstraints]: "
-                                 "task_constraint_ids, Ais, and bis have different size !!!"));
+        throw(std::runtime_error(
+          "[IkProblemFormulation::UpdateEqConstraints]: "
+          "task_constraint_ids, Ais, and bis have different size !!!"));
       }
 
       // check constraint dimension is consistent between input arguments!
@@ -158,16 +161,18 @@ namespace loik
       // check if number of equality constraints has changed
       if (active_task_constraint_ids.size() != static_cast<std::size_t>(nc_eq_))
       {
-        throw(std::runtime_error("[IkProblemFormulation::UpdateEqConstraints]: number of equality "
-                                 "constraints doesn't match initialization!!!"));
+        throw(std::runtime_error(
+          "[IkProblemFormulation::UpdateEqConstraints]: number of equality "
+          "constraints doesn't match initialization!!!"));
       }
 
       // check if equality constraint dim has changed
       if (Ais[0].rows() != eq_c_dim_)
       {
         // TODO: need to check constraint dimension for each Ai and bi, not just the first ones
-        throw(std::runtime_error("[IkProblemFormulation::UpdateEqConstraints]: equality constraint "
-                                 "dimension has changed!!! Updating constraint dimension"));
+        throw(std::runtime_error(
+          "[IkProblemFormulation::UpdateEqConstraints]: equality constraint "
+          "dimension has changed!!! Updating constraint dimension"));
       }
 
       active_task_constraint_ids_ = active_task_constraint_ids;
@@ -206,8 +211,9 @@ namespace loik
       // if 'c_id' not present in 'active_task_constraint_ids_', invoke 'AddEqConstraint()'
       if (found_it == active_task_constraint_ids_.end())
       {
-        throw(std::runtime_error("[IkProblemFormulation::UpdateEqConstraint]: constraint doesn't "
-                                 "yet exist at link 'c_id' !!! "));
+        throw(std::runtime_error(
+          "[IkProblemFormulation::UpdateEqConstraint]: constraint doesn't "
+          "yet exist at link 'c_id' !!! "));
       }
 
       // check if constraint dimension is consistent
@@ -224,9 +230,9 @@ namespace loik
       // if 'c_id' appear more than once, then something went wrong, throw.
       if (c_id_count > 1)
       {
-        throw(
-          std::runtime_error("[IkProblemFormulation::UpdateEqConstraint]: multiple constraint "
-                             "specification for the same link id, not supported, terminating !!!"));
+        throw(std::runtime_error(
+          "[IkProblemFormulation::UpdateEqConstraint]: multiple constraint "
+          "specification for the same link id, not supported, terminating !!!"));
       }
 
       // get index of 'c_id' in 'active_task_constraint_ids_'
@@ -261,8 +267,9 @@ namespace loik
       // if 'c_id' not present in 'active_task_constraint_ids_', then throw
       if (found_it == active_task_constraint_ids_.end())
       {
-        throw(std::runtime_error("[IkProblemFormulation::UpdateEqConstraint]: constraint doesn't "
-                                 "yet exist at link 'c_id' !!! "));
+        throw(std::runtime_error(
+          "[IkProblemFormulation::UpdateEqConstraint]: constraint doesn't "
+          "yet exist at link 'c_id' !!! "));
       }
 
       // get index of 'c_id' in 'active_task_constraint_ids_'
@@ -293,14 +300,16 @@ namespace loik
         // check constraint dimension
         if (Ai.rows() != bi.rows())
         {
-          throw(std::runtime_error("[IkProblemFormulation::AddEqConstraint]: input arguments "
-                                   "constraint dimension inconsistent !!!"));
+          throw(std::runtime_error(
+            "[IkProblemFormulation::AddEqConstraint]: input arguments "
+            "constraint dimension inconsistent !!!"));
         }
 
         if (Ai.rows() != static_cast<std::size_t>(eq_c_dim_))
         {
-          throw(std::runtime_error("[IkProblemFormulation::AddEqConstraint]: input constraint "
-                                   "dimension differ from existing constriant dimension!!!"));
+          throw(std::runtime_error(
+            "[IkProblemFormulation::AddEqConstraint]: input constraint "
+            "dimension differ from existing constriant dimension!!!"));
         }
 
         active_task_constraint_ids_.push_back(c_id);
@@ -370,16 +379,17 @@ namespace loik
       // check arguments have some dimension
       if (lb.size() != ub.size())
       {
-        throw(std::runtime_error("[IkProblemFormulation::UpdateIneqConstraints]: lower bound and "
-                                 "upper bound have different dimensions!!!"));
+        throw(std::runtime_error(
+          "[IkProblemFormulation::UpdateIneqConstraints]: lower bound and "
+          "upper bound have different dimensions!!!"));
       }
 
       // check is inequality constraint dimension has changed
       if (lb.size() != ineq_c_dim_)
       {
-        throw(
-          std::runtime_error("IkProblemFormulation::UpdateIneqConstraints]: inequality constraint "
-                             "dimension has changed, this is not supported currently!!!"));
+        throw(std::runtime_error(
+          "IkProblemFormulation::UpdateIneqConstraints]: inequality constraint "
+          "dimension has changed, this is not supported currently!!!"));
       }
 
       lb_ = lb;
diff --git a/include/loik/ik-id-description.hpp b/include/loik/ik-id-description.hpp
@@ -36,15 +36,16 @@ namespace loik
     {
       if (nj_ != nb_ + 1)
       {
-        throw(std::runtime_error("[IkProblemFormulation::IkProblemFormulation]: nb does not equal "
-                                 "to nj - 1, robot model not supported !!!"));
+        throw(std::runtime_error(
+          "[IkProblemFormulation::IkProblemFormulation]: nb does not equal "
+          "to nj - 1, robot model not supported !!!"));
       }
 
       if (eq_c_dim != 6)
       {
-        throw(
-          std::runtime_error("[IkProblemFormulation::IkProblemFormulation]: equality constraint "
-                             "dimension is not 6, problem formulation not supported !!!"));
+        throw(std::runtime_error(
+          "[IkProblemFormulation::IkProblemFormulation]: equality constraint "
+          "dimension is not 6, problem formulation not supported !!!"));
       }
 
       H_refs_.reserve(static_cast<std::size_t>(nj));
@@ -103,8 +104,9 @@ namespace loik
         H_refs.size() != static_cast<std::size_t>(nj_)
         || v_refs.size() != static_cast<std::size_t>(nj_))
       {
-        throw(std::runtime_error("[IkProblemFormulation::UpdateReferences]: input arguments "
-                                 "'H_refs', 'v_refs' have wrong size!!"));
+        throw(std::runtime_error(
+          "[IkProblemFormulation::UpdateReferences]: input arguments "
+          "'H_refs', 'v_refs' have wrong size!!"));
       }
       H_refs_ = H_refs;
       v_refs_ = v_refs;
@@ -122,8 +124,9 @@ namespace loik
       // check constraint specification is consistant
       if (!((active_task_constraint_ids.size() == Ais.size()) && ((Ais.size() == bis.size()))))
       {
-        throw(std::runtime_error("[IkProblemFormulation::UpdateEqConstraints]: "
-                                 "task_constraint_ids, Ais, and bis have different size !!!"));
+        throw(std::runtime_error(
+          "[IkProblemFormulation::UpdateEqConstraints]: "
+          "task_constraint_ids, Ais, and bis have different size !!!"));
       }
 
       // check constraint dimension is consistent between input arguments!
@@ -136,16 +139,18 @@ namespace loik
       // check if number of equality constraints has changed
       if (active_task_constraint_ids.size() != static_cast<std::size_t>(nc_eq_))
       {
-        throw(std::runtime_error("[IkProblemFormulation::UpdateEqConstraints]: number of equality "
-                                 "constraints doesn't match initialization!!!"));
+        throw(std::runtime_error(
+          "[IkProblemFormulation::UpdateEqConstraints]: number of equality "
+          "constraints doesn't match initialization!!!"));
       }
 
       // check if equality constraint dim has changed
       if (Ais[0].rows() != eq_c_dim_)
       {
         // TODO: need to check constraint dimension for each Ai and bi, not just the first ones
-        throw(std::runtime_error("[IkProblemFormulation::UpdateEqConstraints]: equality constraint "
-                                 "dimension has changed!!! Updating constraint dimension"));
+        throw(std::runtime_error(
+          "[IkProblemFormulation::UpdateEqConstraints]: equality constraint "
+          "dimension has changed!!! Updating constraint dimension"));
       }
 
       active_task_constraint_ids_ = active_task_constraint_ids;
@@ -167,8 +172,9 @@ namespace loik
       // if 'c_id' not present in 'active_task_constraint_ids_', invoke 'AddEqConstraint()'
       if (found_it == active_task_constraint_ids_.end())
       {
-        throw(std::runtime_error("[IkProblemFormulation::UpdateEqConstraint]: constraint doesn't "
-                                 "yet exist at link 'c_id' !!! "));
+        throw(std::runtime_error(
+          "[IkProblemFormulation::UpdateEqConstraint]: constraint doesn't "
+          "yet exist at link 'c_id' !!! "));
       }
 
       // check if constraint dimension is consistent
@@ -185,9 +191,9 @@ namespace loik
       // if 'c_id' appear more than once, then something went wrong, throw.
       if (c_id_count > 1)
       {
-        throw(
-          std::runtime_error("[IkProblemFormulation::UpdateEqConstraint]: multiple constraint "
-                             "specification for the same link id, not supported, terminating !!!"));
+        throw(std::runtime_error(
+          "[IkProblemFormulation::UpdateEqConstraint]: multiple constraint "
+          "specification for the same link id, not supported, terminating !!!"));
       }
 
       // get index of 'c_id' in 'active_task_constraint_ids_'
@@ -212,8 +218,9 @@ namespace loik
       // if 'c_id' not present in 'active_task_constraint_ids_', then throw
       if (found_it == active_task_constraint_ids_.end())
       {
-        throw(std::runtime_error("[IkProblemFormulation::UpdateEqConstraint]: constraint doesn't "
-                                 "yet exist at link 'c_id' !!! "));
+        throw(std::runtime_error(
+          "[IkProblemFormulation::UpdateEqConstraint]: constraint doesn't "
+          "yet exist at link 'c_id' !!! "));
       }
 
       // get index of 'c_id' in 'active_task_constraint_ids_'
@@ -244,14 +251,16 @@ namespace loik
         // check constraint dimension
         if (Ai.rows() != bi.rows())
         {
-          throw(std::runtime_error("[IkProblemFormulation::AddEqConstraint]: input arguments "
-                                   "constraint dimension inconsistent !!!"));
+          throw(std::runtime_error(
+            "[IkProblemFormulation::AddEqConstraint]: input arguments "
+            "constraint dimension inconsistent !!!"));
         }
 
         if (Ai.rows() != static_cast<std::size_t>(eq_c_dim_))
         {
-          throw(std::runtime_error("[IkProblemFormulation::AddEqConstraint]: input constraint "
-                                   "dimension differ from existing constriant dimension!!!"));
+          throw(std::runtime_error(
+            "[IkProblemFormulation::AddEqConstraint]: input constraint "
+            "dimension differ from existing constriant dimension!!!"));
         }
 
         active_task_constraint_ids_.push_back(c_id);
@@ -297,16 +306,17 @@ namespace loik
       // check arguments have some dimension
       if (lb.size() != ub.size())
       {
-        throw(std::runtime_error("[IkProblemFormulation::UpdateIneqConstraints]: lower bound and "
-                                 "upper bound have different dimensions!!!"));
+        throw(std::runtime_error(
+          "[IkProblemFormulation::UpdateIneqConstraints]: lower bound and "
+          "upper bound have different dimensions!!!"));
       }
 
       // check is inequality constraint dimension has changed
       if (lb.size() != ineq_c_dim_)
       {
-        throw(
-          std::runtime_error("IkProblemFormulation::UpdateIneqConstraints]: inequality constraint "
-                             "dimension has changed, this is not supported currently!!!"));
+        throw(std::runtime_error(
+          "IkProblemFormulation::UpdateIneqConstraints]: inequality constraint "
+          "dimension has changed, this is not supported currently!!!"));
       }
 
       lb_ = lb;
@@ -521,8 +531,9 @@ namespace loik
         }
         else
         {
-          throw(std::runtime_error("[IkProblemStandardQPFormulation::UpdateQPADMMSolveInit]: "
-                                   "parent id < 0, this can't happen !!!"));
+          throw(std::runtime_error(
+            "[IkProblemStandardQPFormulation::UpdateQPADMMSolveInit]: "
+            "parent id < 0, this can't happen !!!"));
         }
       }
 
diff --git a/include/loik/loik-loid-optimized.hxx b/include/loik/loik-loid-optimized.hxx
@@ -693,8 +693,9 @@ namespace loik
     else if (this->mu_update_strat_ == ADMMPenaltyUpdateStrat::MAXEIGENVALUE)
     {
       // use max eigen value strategy
-      throw(std::runtime_error("[FirstOrderLoikOptimizedTpl::UpdateMu]: mu update strategy "
-                               "MAXEIGENVALUE not yet implemented"));
+      throw(std::runtime_error(
+        "[FirstOrderLoikOptimizedTpl::UpdateMu]: mu update strategy "
+        "MAXEIGENVALUE not yet implemented"));
     }
     else
     {

Original file line number	Diff line number	Diff line change
`@@ -37,15 +37,16 @@ namespace loik`
`37`	`37`	`{`
`38`	`38`	`if (nj_ != nb_ + 1)`
`39`	`39`	`{`
`40`		`- throw(std::runtime_error("[IkProblemFormulation::IkProblemFormulation]: nb does not equal "`
`41`		`- "to nj - 1, robot model not supported !!!"));`
	`40`	`+ throw(std::runtime_error(`
	`41`	`+ "[IkProblemFormulation::IkProblemFormulation]: nb does not equal "`
	`42`	`+ "to nj - 1, robot model not supported !!!"));`
`42`	`43`	`}`
`43`	`44`
`44`	`45`	`if (eq_c_dim != 6)`
`45`	`46`	`{`
`46`		`- throw(`
`47`		`- std::runtime_error("[IkProblemFormulation::IkProblemFormulation]: equality constraint "`
`48`		`- "dimension is not 6, problem formulation not supported !!!"));`
	`47`	`+ throw(std::runtime_error(`
	`48`	`+ "[IkProblemFormulation::IkProblemFormulation]: equality constraint "`
	`49`	`+ "dimension is not 6, problem formulation not supported !!!"));`
`49`	`50`	`}`
`50`	`51`
`51`	`52`	`H_refs_.reserve(static_cast<std::size_t>(nj));`
`@@ -112,8 +113,9 @@ namespace loik`
`112`	`113`	`H_refs.size() != static_cast<std::size_t>(nj_)`
`113`	`114`	`\|\| v_refs.size() != static_cast<std::size_t>(nj_))`
`114`	`115`	`{`
`115`		`- throw(std::runtime_error("[IkProblemFormulation::UpdateReferences]: input arguments "`
`116`		`- "'H_refs', 'v_refs' have wrong size!!"));`
	`116`	`+ throw(std::runtime_error(`
	`117`	`+ "[IkProblemFormulation::UpdateReferences]: input arguments "`
	`118`	`+ "'H_refs', 'v_refs' have wrong size!!"));`
`117`	`119`	`}`
`118`	`120`	`H_refs_ = H_refs;`
`119`	`121`	`v_refs_ = v_refs;`
`@@ -144,8 +146,9 @@ namespace loik`
`144`	`146`	`// check constraint specification is consistant`
`145`	`147`	`if (!((active_task_constraint_ids.size() == Ais.size()) && ((Ais.size() == bis.size()))))`
`146`	`148`	`{`
`147`		`- throw(std::runtime_error("[IkProblemFormulation::UpdateEqConstraints]: "`
`148`		`- "task_constraint_ids, Ais, and bis have different size !!!"));`
	`149`	`+ throw(std::runtime_error(`
	`150`	`+ "[IkProblemFormulation::UpdateEqConstraints]: "`
	`151`	`+ "task_constraint_ids, Ais, and bis have different size !!!"));`
`149`	`152`	`}`
`150`	`153`
`151`	`154`	`// check constraint dimension is consistent between input arguments!`
`@@ -158,16 +161,18 @@ namespace loik`
`158`	`161`	`// check if number of equality constraints has changed`
`159`	`162`	`if (active_task_constraint_ids.size() != static_cast<std::size_t>(nc_eq_))`
`160`	`163`	`{`
`161`		`- throw(std::runtime_error("[IkProblemFormulation::UpdateEqConstraints]: number of equality "`
`162`		`- "constraints doesn't match initialization!!!"));`
	`164`	`+ throw(std::runtime_error(`
	`165`	`+ "[IkProblemFormulation::UpdateEqConstraints]: number of equality "`
	`166`	`+ "constraints doesn't match initialization!!!"));`
`163`	`167`	`}`
`164`	`168`
`165`	`169`	`// check if equality constraint dim has changed`
`166`	`170`	`if (Ais[0].rows() != eq_c_dim_)`
`167`	`171`	`{`
`168`	`172`	`// TODO: need to check constraint dimension for each Ai and bi, not just the first ones`
`169`		`- throw(std::runtime_error("[IkProblemFormulation::UpdateEqConstraints]: equality constraint "`
`170`		`- "dimension has changed!!! Updating constraint dimension"));`
	`173`	`+ throw(std::runtime_error(`
	`174`	`+ "[IkProblemFormulation::UpdateEqConstraints]: equality constraint "`
	`175`	`+ "dimension has changed!!! Updating constraint dimension"));`
`171`	`176`	`}`
`172`	`177`
`173`	`178`	`active_task_constraint_ids_ = active_task_constraint_ids;`
`@@ -206,8 +211,9 @@ namespace loik`
`206`	`211`	`// if 'c_id' not present in 'active_task_constraint_ids_', invoke 'AddEqConstraint()'`
`207`	`212`	`if (found_it == active_task_constraint_ids_.end())`
`208`	`213`	`{`
`209`		`- throw(std::runtime_error("[IkProblemFormulation::UpdateEqConstraint]: constraint doesn't "`
`210`		`- "yet exist at link 'c_id' !!! "));`
	`214`	`+ throw(std::runtime_error(`
	`215`	`+ "[IkProblemFormulation::UpdateEqConstraint]: constraint doesn't "`
	`216`	`+ "yet exist at link 'c_id' !!! "));`
`211`	`217`	`}`
`212`	`218`
`213`	`219`	`// check if constraint dimension is consistent`
`@@ -224,9 +230,9 @@ namespace loik`
`224`	`230`	`// if 'c_id' appear more than once, then something went wrong, throw.`
`225`	`231`	`if (c_id_count > 1)`
`226`	`232`	`{`
`227`		`- throw(`
`228`		`- std::runtime_error("[IkProblemFormulation::UpdateEqConstraint]: multiple constraint "`
`229`		`- "specification for the same link id, not supported, terminating !!!"));`
	`233`	`+ throw(std::runtime_error(`
	`234`	`+ "[IkProblemFormulation::UpdateEqConstraint]: multiple constraint "`
	`235`	`+ "specification for the same link id, not supported, terminating !!!"));`
`230`	`236`	`}`
`231`	`237`
`232`	`238`	`// get index of 'c_id' in 'active_task_constraint_ids_'`
`@@ -261,8 +267,9 @@ namespace loik`
`261`	`267`	`// if 'c_id' not present in 'active_task_constraint_ids_', then throw`
`262`	`268`	`if (found_it == active_task_constraint_ids_.end())`
`263`	`269`	`{`
`264`		`- throw(std::runtime_error("[IkProblemFormulation::UpdateEqConstraint]: constraint doesn't "`
`265`		`- "yet exist at link 'c_id' !!! "));`
	`270`	`+ throw(std::runtime_error(`
	`271`	`+ "[IkProblemFormulation::UpdateEqConstraint]: constraint doesn't "`
	`272`	`+ "yet exist at link 'c_id' !!! "));`
`266`	`273`	`}`
`267`	`274`
`268`	`275`	`// get index of 'c_id' in 'active_task_constraint_ids_'`
`@@ -293,14 +300,16 @@ namespace loik`
`293`	`300`	`// check constraint dimension`
`294`	`301`	`if (Ai.rows() != bi.rows())`
`295`	`302`	`{`
`296`		`- throw(std::runtime_error("[IkProblemFormulation::AddEqConstraint]: input arguments "`
`297`		`- "constraint dimension inconsistent !!!"));`
	`303`	`+ throw(std::runtime_error(`
	`304`	`+ "[IkProblemFormulation::AddEqConstraint]: input arguments "`
	`305`	`+ "constraint dimension inconsistent !!!"));`
`298`	`306`	`}`
`299`	`307`
`300`	`308`	`if (Ai.rows() != static_cast<std::size_t>(eq_c_dim_))`
`301`	`309`	`{`
`302`		`- throw(std::runtime_error("[IkProblemFormulation::AddEqConstraint]: input constraint "`
`303`		`- "dimension differ from existing constriant dimension!!!"));`
	`310`	`+ throw(std::runtime_error(`
	`311`	`+ "[IkProblemFormulation::AddEqConstraint]: input constraint "`
	`312`	`+ "dimension differ from existing constriant dimension!!!"));`
`304`	`313`	`}`
`305`	`314`
`306`	`315`	`active_task_constraint_ids_.push_back(c_id);`
`@@ -370,16 +379,17 @@ namespace loik`
`370`	`379`	`// check arguments have some dimension`
`371`	`380`	`if (lb.size() != ub.size())`
`372`	`381`	`{`
`373`		`- throw(std::runtime_error("[IkProblemFormulation::UpdateIneqConstraints]: lower bound and "`
`374`		`- "upper bound have different dimensions!!!"));`
	`382`	`+ throw(std::runtime_error(`
	`383`	`+ "[IkProblemFormulation::UpdateIneqConstraints]: lower bound and "`
	`384`	`+ "upper bound have different dimensions!!!"));`
`375`	`385`	`}`
`376`	`386`
`377`	`387`	`// check is inequality constraint dimension has changed`
`378`	`388`	`if (lb.size() != ineq_c_dim_)`
`379`	`389`	`{`
`380`		`- throw(`
`381`		`- std::runtime_error("IkProblemFormulation::UpdateIneqConstraints]: inequality constraint "`
`382`		`- "dimension has changed, this is not supported currently!!!"));`
	`390`	`+ throw(std::runtime_error(`
	`391`	`+ "IkProblemFormulation::UpdateIneqConstraints]: inequality constraint "`
	`392`	`+ "dimension has changed, this is not supported currently!!!"));`
`383`	`393`	`}`
`384`	`394`
`385`	`395`	`lb_ = lb;`
Original file line number	Diff line number	Diff line change
`@@ -36,15 +36,16 @@ namespace loik`
`36`	`36`	`{`
`37`	`37`	`if (nj_ != nb_ + 1)`
`38`	`38`	`{`
`39`		`- throw(std::runtime_error("[IkProblemFormulation::IkProblemFormulation]: nb does not equal "`
`40`		`- "to nj - 1, robot model not supported !!!"));`
	`39`	`+ throw(std::runtime_error(`
	`40`	`+ "[IkProblemFormulation::IkProblemFormulation]: nb does not equal "`
	`41`	`+ "to nj - 1, robot model not supported !!!"));`
`41`	`42`	`}`
`42`	`43`
`43`	`44`	`if (eq_c_dim != 6)`
`44`	`45`	`{`
`45`		`- throw(`
`46`		`- std::runtime_error("[IkProblemFormulation::IkProblemFormulation]: equality constraint "`
`47`		`- "dimension is not 6, problem formulation not supported !!!"));`
	`46`	`+ throw(std::runtime_error(`
	`47`	`+ "[IkProblemFormulation::IkProblemFormulation]: equality constraint "`
	`48`	`+ "dimension is not 6, problem formulation not supported !!!"));`
`48`	`49`	`}`
`49`	`50`
`50`	`51`	`H_refs_.reserve(static_cast<std::size_t>(nj));`
`@@ -103,8 +104,9 @@ namespace loik`
`103`	`104`	`H_refs.size() != static_cast<std::size_t>(nj_)`
`104`	`105`	`\|\| v_refs.size() != static_cast<std::size_t>(nj_))`
`105`	`106`	`{`
`106`		`- throw(std::runtime_error("[IkProblemFormulation::UpdateReferences]: input arguments "`
`107`		`- "'H_refs', 'v_refs' have wrong size!!"));`
	`107`	`+ throw(std::runtime_error(`
	`108`	`+ "[IkProblemFormulation::UpdateReferences]: input arguments "`
	`109`	`+ "'H_refs', 'v_refs' have wrong size!!"));`
`108`	`110`	`}`
`109`	`111`	`H_refs_ = H_refs;`
`110`	`112`	`v_refs_ = v_refs;`
`@@ -122,8 +124,9 @@ namespace loik`
`122`	`124`	`// check constraint specification is consistant`
`123`	`125`	`if (!((active_task_constraint_ids.size() == Ais.size()) && ((Ais.size() == bis.size()))))`
`124`	`126`	`{`
`125`		`- throw(std::runtime_error("[IkProblemFormulation::UpdateEqConstraints]: "`
`126`		`- "task_constraint_ids, Ais, and bis have different size !!!"));`
	`127`	`+ throw(std::runtime_error(`
	`128`	`+ "[IkProblemFormulation::UpdateEqConstraints]: "`
	`129`	`+ "task_constraint_ids, Ais, and bis have different size !!!"));`
`127`	`130`	`}`
`128`	`131`
`129`	`132`	`// check constraint dimension is consistent between input arguments!`
`@@ -136,16 +139,18 @@ namespace loik`
`136`	`139`	`// check if number of equality constraints has changed`
`137`	`140`	`if (active_task_constraint_ids.size() != static_cast<std::size_t>(nc_eq_))`
`138`	`141`	`{`
`139`		`- throw(std::runtime_error("[IkProblemFormulation::UpdateEqConstraints]: number of equality "`
`140`		`- "constraints doesn't match initialization!!!"));`
	`142`	`+ throw(std::runtime_error(`
	`143`	`+ "[IkProblemFormulation::UpdateEqConstraints]: number of equality "`
	`144`	`+ "constraints doesn't match initialization!!!"));`
`141`	`145`	`}`
`142`	`146`
`143`	`147`	`// check if equality constraint dim has changed`
`144`	`148`	`if (Ais[0].rows() != eq_c_dim_)`
`145`	`149`	`{`
`146`	`150`	`// TODO: need to check constraint dimension for each Ai and bi, not just the first ones`
`147`		`- throw(std::runtime_error("[IkProblemFormulation::UpdateEqConstraints]: equality constraint "`
`148`		`- "dimension has changed!!! Updating constraint dimension"));`
	`151`	`+ throw(std::runtime_error(`
	`152`	`+ "[IkProblemFormulation::UpdateEqConstraints]: equality constraint "`
	`153`	`+ "dimension has changed!!! Updating constraint dimension"));`
`149`	`154`	`}`
`150`	`155`
`151`	`156`	`active_task_constraint_ids_ = active_task_constraint_ids;`
`@@ -167,8 +172,9 @@ namespace loik`
`167`	`172`	`// if 'c_id' not present in 'active_task_constraint_ids_', invoke 'AddEqConstraint()'`
`168`	`173`	`if (found_it == active_task_constraint_ids_.end())`
`169`	`174`	`{`
`170`		`- throw(std::runtime_error("[IkProblemFormulation::UpdateEqConstraint]: constraint doesn't "`
`171`		`- "yet exist at link 'c_id' !!! "));`
	`175`	`+ throw(std::runtime_error(`
	`176`	`+ "[IkProblemFormulation::UpdateEqConstraint]: constraint doesn't "`
	`177`	`+ "yet exist at link 'c_id' !!! "));`
`172`	`178`	`}`
`173`	`179`
`174`	`180`	`// check if constraint dimension is consistent`
`@@ -185,9 +191,9 @@ namespace loik`
`185`	`191`	`// if 'c_id' appear more than once, then something went wrong, throw.`
`186`	`192`	`if (c_id_count > 1)`
`187`	`193`	`{`
`188`		`- throw(`
`189`		`- std::runtime_error("[IkProblemFormulation::UpdateEqConstraint]: multiple constraint "`
`190`		`- "specification for the same link id, not supported, terminating !!!"));`
	`194`	`+ throw(std::runtime_error(`
	`195`	`+ "[IkProblemFormulation::UpdateEqConstraint]: multiple constraint "`
	`196`	`+ "specification for the same link id, not supported, terminating !!!"));`
`191`	`197`	`}`
`192`	`198`
`193`	`199`	`// get index of 'c_id' in 'active_task_constraint_ids_'`
`@@ -212,8 +218,9 @@ namespace loik`
`212`	`218`	`// if 'c_id' not present in 'active_task_constraint_ids_', then throw`
`213`	`219`	`if (found_it == active_task_constraint_ids_.end())`
`214`	`220`	`{`
`215`		`- throw(std::runtime_error("[IkProblemFormulation::UpdateEqConstraint]: constraint doesn't "`
`216`		`- "yet exist at link 'c_id' !!! "));`
	`221`	`+ throw(std::runtime_error(`
	`222`	`+ "[IkProblemFormulation::UpdateEqConstraint]: constraint doesn't "`
	`223`	`+ "yet exist at link 'c_id' !!! "));`
`217`	`224`	`}`
`218`	`225`
`219`	`226`	`// get index of 'c_id' in 'active_task_constraint_ids_'`
`@@ -244,14 +251,16 @@ namespace loik`
`244`	`251`	`// check constraint dimension`
`245`	`252`	`if (Ai.rows() != bi.rows())`
`246`	`253`	`{`
`247`		`- throw(std::runtime_error("[IkProblemFormulation::AddEqConstraint]: input arguments "`
`248`		`- "constraint dimension inconsistent !!!"));`
	`254`	`+ throw(std::runtime_error(`
	`255`	`+ "[IkProblemFormulation::AddEqConstraint]: input arguments "`
	`256`	`+ "constraint dimension inconsistent !!!"));`
`249`	`257`	`}`
`250`	`258`
`251`	`259`	`if (Ai.rows() != static_cast<std::size_t>(eq_c_dim_))`
`252`	`260`	`{`
`253`		`- throw(std::runtime_error("[IkProblemFormulation::AddEqConstraint]: input constraint "`
`254`		`- "dimension differ from existing constriant dimension!!!"));`
	`261`	`+ throw(std::runtime_error(`
	`262`	`+ "[IkProblemFormulation::AddEqConstraint]: input constraint "`
	`263`	`+ "dimension differ from existing constriant dimension!!!"));`
`255`	`264`	`}`
`256`	`265`
`257`	`266`	`active_task_constraint_ids_.push_back(c_id);`
`@@ -297,16 +306,17 @@ namespace loik`
`297`	`306`	`// check arguments have some dimension`
`298`	`307`	`if (lb.size() != ub.size())`
`299`	`308`	`{`
`300`		`- throw(std::runtime_error("[IkProblemFormulation::UpdateIneqConstraints]: lower bound and "`
`301`		`- "upper bound have different dimensions!!!"));`
	`309`	`+ throw(std::runtime_error(`
	`310`	`+ "[IkProblemFormulation::UpdateIneqConstraints]: lower bound and "`
	`311`	`+ "upper bound have different dimensions!!!"));`
`302`	`312`	`}`
`303`	`313`
`304`	`314`	`// check is inequality constraint dimension has changed`
`305`	`315`	`if (lb.size() != ineq_c_dim_)`
`306`	`316`	`{`
`307`		`- throw(`
`308`		`- std::runtime_error("IkProblemFormulation::UpdateIneqConstraints]: inequality constraint "`
`309`		`- "dimension has changed, this is not supported currently!!!"));`
	`317`	`+ throw(std::runtime_error(`
	`318`	`+ "IkProblemFormulation::UpdateIneqConstraints]: inequality constraint "`
	`319`	`+ "dimension has changed, this is not supported currently!!!"));`
`310`	`320`	`}`
`311`	`321`
`312`	`322`	`lb_ = lb;`
`@@ -521,8 +531,9 @@ namespace loik`
`521`	`531`	`}`
`522`	`532`	`else`
`523`	`533`	`{`
`524`		`- throw(std::runtime_error("[IkProblemStandardQPFormulation::UpdateQPADMMSolveInit]: "`
`525`		`- "parent id < 0, this can't happen !!!"));`
	`534`	`+ throw(std::runtime_error(`
	`535`	`+ "[IkProblemStandardQPFormulation::UpdateQPADMMSolveInit]: "`
	`536`	`+ "parent id < 0, this can't happen !!!"));`
`526`	`537`	`}`
`527`	`538`	`}`
`528`	`539`
Original file line number	Diff line number	Diff line change
`@@ -693,8 +693,9 @@ namespace loik`
`693`	`693`	`else if (this->mu_update_strat_ == ADMMPenaltyUpdateStrat::MAXEIGENVALUE)`
`694`	`694`	`{`
`695`	`695`	`// use max eigen value strategy`
`696`		`- throw(std::runtime_error("[FirstOrderLoikOptimizedTpl::UpdateMu]: mu update strategy "`
`697`		`- "MAXEIGENVALUE not yet implemented"));`
	`696`	`+ throw(std::runtime_error(`
	`697`	`+ "[FirstOrderLoikOptimizedTpl::UpdateMu]: mu update strategy "`
	`698`	`+ "MAXEIGENVALUE not yet implemented"));`
`698`	`699`	`}`
`699`	`700`	`else`
`700`	`701`	`{`