Merge pull request #368 from Simple-Robotics/remove-deprecated-stageconstraint-class

(Finally) remove deprecated `StageConstraint` template class

Author: ManifoldFR

CHANGELOG.md

@@ -32,7 +32,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Removed
 
 - modelling/multibody : remove txx files, remove `context.hpp`
-- core : remove `callback-base.txx`
+- core : remove `callback-base.txx`, remove `constraint.txx`
+- core : remove deprecated class template `StageConstraintTpl`, and its Python bindings
 
 ## [0.16.0] - 2025-10-15
 

bindings/python/src/expose-constraint.cpp

@@ -9,16 +9,10 @@
 namespace aligator::python {
 using context::ConstraintSet;
 using context::ConstraintStack;
-using context::StageConstraint;
 using context::StageFunction;
 using PolyFunc = xyz::polymorphic<StageFunction>;
 using PolySet = xyz::polymorphic<ConstraintSet>;
 
-context::StageConstraint *make_constraint_wrap(const PolyFunc &f,
-                                               const PolySet &c) {
-  return new context::StageConstraint{f, c};
-}
-
 void exposeConstraintSets();
 
 void exposeConstraint() {
@@ -27,27 +21,6 @@ void exposeConstraint() {
     exposeConstraintSets();
   }
 
-  bp::class_<StageConstraint>(
-      "StageConstraint",
-      "A stage-wise constraint, of the form :math:`c(x,u) \\leq 0 c(x,u)`.\n"
-      ":param f: underlying function\n"
-      ":param cs: constraint set",
-      bp::no_init)
-      .def("__init__",
-           bp::make_constructor(
-               make_constraint_wrap,
-               eigenpy::deprecation_warning_policy<>(
-                   "This class has been deprecated and will be removed in a "
-                   "future version of aligator."),
-               ("func"_a, "cstr_set")),
-           "Contruct a StageConstraint from a StageFunction and a constraint "
-           "set.")
-      .def_readwrite("func", &StageConstraint::func)
-      .def_readwrite("set", &StageConstraint::set)
-      .add_property(
-          "nr", +[](StageConstraint const &el) { return el.func->nr; },
-          "Get constraint dimension.");
-
   bp::class_<ConstraintStack>("ConstraintStack", "The stack of constraint.",
                               bp::no_init)
       .add_property("size", &ConstraintStack::size,

bindings/python/src/expose-problem.cpp

@@ -58,11 +58,6 @@ void exposeProblem() {
                     &TrajOptProblem::setInitState, "Initial state.")
       .add_property("init_constraint", &TrajOptProblem::init_constraint_,
                     "Get initial state constraint.")
-      .def<void (TrajOptProblem::*)(const context::StageConstraint &)>(
-          "addTerminalConstraint", &TrajOptProblem::addTerminalConstraint,
-          eigenpy::deprecated_member<>("This method is deprecated (because "
-                                       "StageConstraint has been deprecated)."),
-          ("self"_a, "constraint"), "Add a terminal constraint.")
       .def<void (TrajOptProblem::*)(const PolyFunction &, const PolySet &)>(
           "addTerminalConstraint", &TrajOptProblem::addTerminalConstraint,
           ("self"_a, "func", "set"), "Add a terminal constraint.")

bindings/python/src/expose-stage.cpp

@@ -55,11 +55,6 @@ void exposeStage() {
       bp::no_init)
       .def(bp::init<const PolyCost &, const PolyDynamics &>(
           ("self"_a, "cost", "dynamics")))
-      .def<void (StageModel::*)(const context::StageConstraint &)>(
-          "addConstraint", &StageModel::addConstraint,
-          eigenpy::deprecated_member<>("This method has been deprecated since "
-                                       "StageConstraint is deprecated."),
-          ("self"_a, "constraint"), "Add an existing constraint to the stage.")
       .def<void (StageModel::*)(const PolyFunction &, const PolyCstrSet &)>(
           "addConstraint", &StageModel::addConstraint,
           ("self"_a, "func", "cstr_set"),

examples/clqr.cpp

@@ -4,7 +4,8 @@
 #include "aligator/modelling/state-error.hpp"
 #include "aligator/solvers/proxddp/solver-proxddp.hpp"
 
-#include "aligator/modelling/constraints.hpp"
+#include "aligator/modelling/constraints/box-constraint.hpp"
+#include "aligator/modelling/constraints/equality-constraint.hpp"
 #include <aligator/fmt-eigen.hpp>
 #include <iostream>
 #include "../tests/test_util.hpp"

include/aligator/context.hpp

@@ -17,7 +17,6 @@ using VectorSpace = VectorSpaceTpl<Scalar, Eigen::Dynamic>;
 using StageFunction = StageFunctionTpl<Scalar>;
 using UnaryFunction = UnaryFunctionTpl<Scalar>;
 using StageFunctionData = StageFunctionDataTpl<Scalar>;
-using StageConstraint ALIGATOR_DEPRECATED = StageConstraintTpl<Scalar>;
 
 using ConstraintSet = ConstraintSetTpl<Scalar>;
 

include/aligator/core/constraint.hpp

@@ -10,13 +10,6 @@
 
 namespace aligator {
 
-/// @brief Simple struct holding together a function and set, to describe a
-/// constraint.
-template <typename Scalar> struct ALIGATOR_DEPRECATED StageConstraintTpl {
-  xyz::polymorphic<StageFunctionTpl<Scalar>> func;
-  xyz::polymorphic<ConstraintSetTpl<Scalar>> set;
-};
-
 /// @brief Convenience class to manage a stack of constraints.
 template <typename Scalar> struct ConstraintStackTpl {
   ALIGATOR_DYNAMIC_TYPEDEFS(Scalar);
@@ -95,8 +88,7 @@ template <typename Scalar> void ConstraintStackTpl<Scalar>::clear() {
   total_dim_ = 0;
 }
 
-} // namespace aligator
-
 #ifdef ALIGATOR_ENABLE_TEMPLATE_INSTANTIATION
-#include "aligator/core/constraint.txx"
+extern template struct ConstraintStackTpl<context::Scalar>;
 #endif
+} // namespace aligator

include/aligator/core/constraint.txx

@@ -32,10 +32,6 @@ template <typename _Scalar> struct StageModelTpl {
   using PolyConstraintSet = polymorphic<ConstraintSetTpl<Scalar>>;
   using Cost = CostAbstractTpl<Scalar>;
   using PolyCost = polymorphic<Cost>;
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-  using StageConstraint = StageConstraintTpl<Scalar>;
-#pragma GCC diagnostic pop
   using Data = StageDataTpl<Scalar>;
 
   /// State space for the current state \f$x_k\f$.
@@ -105,12 +101,6 @@ template <typename _Scalar> struct StageModelTpl {
   int numDual() const { return ndx2() + nc(); }
 
   /// @brief    Add a constraint to the stage.
-  template <typename Cstr, typename = std::enable_if_t<std::is_same_v<
-                               std::decay_t<Cstr>, StageConstraint>>>
-  ALIGATOR_DEPRECATED void addConstraint(Cstr &&cstr);
-
-  /// @copybrief  addConstraint().
-  /// @details    Adds a constraint by allocating a new StageConstraintTpl.
   void addConstraint(const PolyFunction &func,
                      const PolyConstraintSet &cstr_set);
 
@@ -135,18 +125,6 @@ template <typename _Scalar> struct StageModelTpl {
   virtual shared_ptr<Data> createData() const;
 };
 
-template <typename Scalar>
-template <typename Cstr, typename>
-void StageModelTpl<Scalar>::addConstraint(Cstr &&cstr) {
-  const int c_nu = cstr.func->nu;
-  if (c_nu != this->nu()) {
-    ALIGATOR_RUNTIME_ERROR(
-        "Function has the wrong dimension for u: got {:d}, expected {:d}", c_nu,
-        this->nu());
-  }
-  constraints_.pushBack(std::forward<Cstr>(cstr));
-}
-
 #ifdef ALIGATOR_ENABLE_TEMPLATE_INSTANTIATION
 extern template struct StageModelTpl<context::Scalar>;
 #endif

include/aligator/core/stage-model.hpp

@@ -51,8 +51,8 @@ namespace aligator {
  * # Stage models
  * A stage model (StageModelTpl) describes a node in the discrete-time optimal
  * control problem: it consists in a running cost function, and a vector of
- * constraints (StageConstraintTpl), the first of which @b must describe
- * system dynamics (through a DynamicsModelTpl).
+ * constraints, the first of which @b must describe system dynamics (through a
+ * ExplicitDynamicsModelTpl).
  *
  * # Example
  *
@@ -113,10 +113,6 @@ template <typename _Scalar> struct TrajOptProblemTpl {
   using CostAbstract = CostAbstractTpl<Scalar>;
   using ConstraintSet = ConstraintSetTpl<Scalar>;
   using StateErrorResidual = StateErrorResidualTpl<Scalar>;
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-  using StageConstraint = StageConstraintTpl<Scalar>;
-#pragma GCC diagnostic pop
   using InitializationStrategy =
       std::function<void(const Self &, std::vector<VectorXs> &)>;
 
@@ -185,12 +181,11 @@ template <typename _Scalar> struct TrajOptProblemTpl {
   }
 
   /// @brief Add a terminal constraint for the model.
-  ALIGATOR_DEPRECATED void addTerminalConstraint(const StageConstraint &cstr);
-  /// @copybrief addTerminalConstraint()
   void addTerminalConstraint(const xyz::polymorphic<StageFunction> &func,
                              const xyz::polymorphic<ConstraintSet> &set) {
     this->term_cstrs_.pushBack(func, set);
   }
+
   /// @brief Remove all terminal constraints.
   void removeTerminalConstraints() { term_cstrs_.clear(); }