Switch shared_ptr<T> for polymorphic<T> for several classes

.github/workflows/conda/conda-env.yml

@@ -13,7 +13,7 @@ dependencies:
   - pinocchio>=3.0.0
   - eigen
   - fmt
-  - proxsuite-nlp
+  - proxsuite-nlp>=0.8.0
   - benchmark
   - crocoddyl
   - example-robot-data

.github/workflows/publish.yml

@@ -22,12 +22,12 @@ jobs:
       matrix:
         os: ["ubuntu-latest", "macos-latest"]
         build_type: [Release]
-        python-version: ["3.8", "3.10", "3.12"]
+        python-version: ["3.10", "3.11", "3.12"]
         include:
-          - python-version: "3.8"
-            numpy-version: "1.22"
           - python-version: "3.10"
             numpy-version: "1.22"
+          - python-version: "3.11"
+            numpy-version: "1.24"
           - python-version: "3.12"
             numpy-version: "1.26"
     steps:

CHANGELOG.md

@@ -7,6 +7,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Changed
+
+- Change storage for `ConstraintStack` to using two `std::vector<polymorphic<>>` the struct `StageConstraintTpl` is now merely a convenient API shortcut for the end-user.
+- Remove `StageConstraintTpl::nr()` (in C++ only)
+- Update minimum required version of eigenpy to 3.7.0
+- Add tracy macros to `stage-model.hxx`
+- Change minimum required version of proxsuite-nlp to 0.8.0
+
 ## [0.7.0] - 2024-09-12
 
 ### Changed

CMakeLists.txt

@@ -197,14 +197,12 @@ add_project_dependency(Boost REQUIRED COMPONENTS ${BOOST_REQUIRED_COMPONENTS})
 if(BUILD_PYTHON_INTERFACE)
   set(PYTHON_COMPONENTS Interpreter Development NumPy)
   findpython(REQUIRED)
-  add_project_dependency(eigenpy 3.4.0 REQUIRED PKG_CONFIG_REQUIRES "eigenpy >= 3.4.0")
+  add_project_dependency(eigenpy 3.7.0 REQUIRED PKG_CONFIG_REQUIRES "eigenpy >= 3.7.0")
   set(PYLIB_NAME "py${PROJECT_NAME}")
   set(${PYLIB_NAME}_INSTALL_DIR ${PYTHON_SITELIB}/${PROJECT_NAME})
 endif()
 
-add_project_dependency(
-  proxsuite-nlp 0.7.0 REQUIRED PKG_CONFIG_REQUIRES "0.7.0 <= proxsuite-nlp < 0.8.0"
-)
+add_project_dependency(proxsuite-nlp 0.8.0 REQUIRED PKG_CONFIG_REQUIRES "proxsuite-nlp >= 0.8.0")
 
 set(LIB_SOURCES src/utils/logger.cpp)
 

bench/lqr.cpp

@@ -39,11 +39,11 @@ TrajOptProblem define_problem(const std::size_t nsteps, const int dim = 56,
 
   using Dynamics = dynamics::LinearDiscreteDynamicsTpl<T>;
   using QuadCost = QuadraticCostTpl<T>;
-  auto dynptr = std::make_shared<Dynamics>(A, B, c_);
-  auto space = dynptr->space_next_;
+  auto dynptr = Dynamics(A, B, c_);
+  auto space = dynptr.space_next_;
 
-  auto rcost = std::make_shared<QuadCost>(w_x, w_u);
-  auto stage = std::make_shared<StageModel>(rcost, dynptr);
+  auto rcost = QuadCost(w_x, w_u);
+  auto stage = StageModel(rcost, dynptr);
   auto term_cost = rcost;
 
   VectorXd x0(dim);

bindings/python/include/aligator/python/costs.hpp

@@ -6,42 +6,50 @@
 
 namespace aligator {
 namespace python {
-namespace internal {
 /// @brief Wrapper for the CostDataAbstractTpl class and its children.
-template <typename T = context::CostAbstract>
-struct PyCostFunction : T, bp::wrapper<T> {
+struct PyCostFunction final
+    : context::CostAbstract,
+      proxsuite::nlp::python::PolymorphicWrapper<PyCostFunction,
+                                                 context::CostAbstract> {
   using Scalar = context::Scalar;
-  using bp::wrapper<T>::get_override;
+  using T = context::CostAbstract;
   using CostData = CostDataAbstractTpl<Scalar>;
+  using context::CostAbstract::CostAbstractTpl;
   ALIGATOR_DYNAMIC_TYPEDEFS(Scalar);
 
-  /// forwarding constructor
-  template <typename... Args>
-  PyCostFunction(Args &&...args) : T(std::forward<Args>(args)...) {}
-
-  virtual void evaluate(const ConstVectorRef &x, const ConstVectorRef &u,
-                        CostData &data) const override {
+  void evaluate(const ConstVectorRef &x, const ConstVectorRef &u,
+                CostData &data) const override {
     ALIGATOR_PYTHON_OVERRIDE_PURE(void, "evaluate", x, u, boost::ref(data));
   }
 
-  virtual void computeGradients(const ConstVectorRef &x,
-                                const ConstVectorRef &u,
-                                CostData &data) const override {
+  void computeGradients(const ConstVectorRef &x, const ConstVectorRef &u,
+                        CostData &data) const override {
     ALIGATOR_PYTHON_OVERRIDE_PURE(void, "computeGradients", x, u,
                                   boost::ref(data));
   }
 
-  virtual void computeHessians(const ConstVectorRef &x, const ConstVectorRef &u,
-                               CostData &data) const override {
+  void computeHessians(const ConstVectorRef &x, const ConstVectorRef &u,
+                       CostData &data) const override {
     ALIGATOR_PYTHON_OVERRIDE_PURE(void, "computeHessians", x, u,
                                   boost::ref(data));
   }
 
-  virtual shared_ptr<CostData> createData() const override {
+  shared_ptr<CostData> createData() const override {
     ALIGATOR_PYTHON_OVERRIDE(shared_ptr<CostData>, T, createData, );
   }
-};
-} // namespace internal
 
+  shared_ptr<CostData> default_createData() const { return T::createData(); }
+};
 } // namespace python
 } // namespace aligator
+
+namespace boost::python::objects {
+
+template <>
+struct value_holder<aligator::python::PyCostFunction>
+    : proxsuite::nlp::python::OwningNonOwningHolder<
+          aligator::python::PyCostFunction> {
+  using OwningNonOwningHolder::OwningNonOwningHolder;
+};
+
+} // namespace boost::python::objects

bindings/python/include/aligator/python/functions.hpp

@@ -6,10 +6,17 @@
 
 #include "aligator/core/function-abstract.hpp"
 #include "aligator/core/unary-function.hpp"
+#include "aligator/core/dynamics.hpp"
+
+#include "aligator/modelling/dynamics/context.hpp"
+#include "aligator/modelling/dynamics/integrator-abstract.hpp"
+
+#include "aligator/python/polymorphic-convertible.hpp"
+
+#include "proxsuite-nlp/python/polymorphic.hpp"
 
 namespace aligator {
 namespace python {
-namespace internal {
 /// Wrapper for the StageFunction class and any virtual children that avoids
 /// having to redeclare Python overrides for these children.
 ///
@@ -18,15 +25,15 @@ namespace internal {
 ///
 /// @tparam FunctionBase The virtual class to expose.
 template <class FunctionBase = context::StageFunction>
-struct PyStageFunction : FunctionBase, bp::wrapper<FunctionBase> {
+struct PyStageFunction final
+    : FunctionBase,
+      proxsuite::nlp::python::PolymorphicWrapper<PyStageFunction<FunctionBase>,
+                                                 FunctionBase> {
   using Scalar = typename FunctionBase::Scalar;
   using Data = StageFunctionDataTpl<Scalar>;
+  using FunctionBase::FunctionBase;
   ALIGATOR_DYNAMIC_TYPEDEFS(Scalar);
 
-  // Use perfect forwarding to the FunctionBase constructors.
-  template <typename... Args>
-  PyStageFunction(Args &&...args) : FunctionBase(std::forward<Args>(args)...) {}
-
   void evaluate(const ConstVectorRef &x, const ConstVectorRef &u,
                 const ConstVectorRef &y, Data &data) const override {
     ALIGATOR_PYTHON_OVERRIDE_PURE(void, "evaluate", x, u, y, boost::ref(data));
@@ -57,7 +64,10 @@ struct PyStageFunction : FunctionBase, bp::wrapper<FunctionBase> {
 };
 
 template <typename UFunction = context::UnaryFunction>
-struct PyUnaryFunction : UFunction, bp::wrapper<UFunction> {
+struct PyUnaryFunction final
+    : UFunction,
+      proxsuite::nlp::python::PolymorphicWrapper<PyUnaryFunction<UFunction>,
+                                                 UFunction> {
   using Scalar = typename UFunction::Scalar;
   static_assert(
       std::is_base_of_v<UnaryFunctionTpl<Scalar>, UFunction>,
@@ -89,14 +99,20 @@ struct PyUnaryFunction : UFunction, bp::wrapper<UFunction> {
                                             Data &data) const {
     UFunction::computeVectorHessianProducts(x, lbda, data);
   }
-};
 
-} // namespace internal
+  shared_ptr<Data> createData() const override {
+    ALIGATOR_PYTHON_OVERRIDE(shared_ptr<Data>, UFunction, createData, );
+  }
+
+  shared_ptr<Data> default_createData() const {
+    return UFunction::createData();
+  }
+};
 
 template <typename Class>
 struct SlicingVisitor : bp::def_visitor<SlicingVisitor<Class>> {
   using Scalar = typename Class::Scalar;
-  using FS = FunctionSliceXprTpl<Scalar, Class>;
+  using SliceType = FunctionSliceXprTpl<Scalar, Class>;
 
   template <typename Iterator, typename Fn>
   static auto do_with_slice(Fn &&fun, bp::slice::range<Iterator> &range) {
@@ -107,23 +123,24 @@ struct SlicingVisitor : bp::def_visitor<SlicingVisitor<Class>> {
     fun(*range.start);
   }
 
-  static auto get_slice(shared_ptr<Class> const &fn, bp::slice slice_obj) {
+  static auto get_slice(xyz::polymorphic<Class> const &fn,
+                        bp::slice slice_obj) {
     std::vector<int> indices((unsigned)fn->nr);
     std::iota(indices.begin(), indices.end(), 0);
     auto bounds = slice_obj.get_indices(indices.cbegin(), indices.cend());
     std::vector<int> out{};
 
     do_with_slice([&](int i) { out.push_back(i); }, bounds);
-    return std::make_shared<FS>(fn, out);
+    return SliceType(fn, out);
   }
 
-  static auto get_from_index(shared_ptr<Class> const &fn, const int idx) {
-    return std::make_shared<FS>(fn, idx);
+  static auto get_from_index(xyz::polymorphic<Class> const &fn, const int idx) {
+    return SliceType(fn, idx);
   }
 
-  static auto get_from_indices(shared_ptr<Class> const &fn,
+  static auto get_from_indices(xyz::polymorphic<Class> const &fn,
                                std::vector<int> const &indices) {
-    return std::make_shared<FS>(fn, indices);
+    return SliceType(fn, indices);
   }
 
   template <typename... Args> void visit(bp::class_<Args...> &cl) const {
@@ -135,3 +152,38 @@ struct SlicingVisitor : bp::def_visitor<SlicingVisitor<Class>> {
 
 } // namespace python
 } // namespace aligator
+
+namespace boost::python::objects {
+
+template <>
+struct value_holder<aligator::python::PyStageFunction<>>
+    : proxsuite::nlp::python::OwningNonOwningHolder<
+          aligator::python::PyStageFunction<>> {
+  using OwningNonOwningHolder::OwningNonOwningHolder;
+};
+
+template <>
+struct value_holder<
+    aligator::python::PyStageFunction<aligator::context::DynamicsModel>>
+    : proxsuite::nlp::python::OwningNonOwningHolder<
+          aligator::python::PyStageFunction<aligator::context::DynamicsModel>> {
+  using OwningNonOwningHolder::OwningNonOwningHolder;
+};
+
+template <>
+struct value_holder<
+    aligator::python::PyStageFunction<aligator::context::IntegratorAbstract>>
+    : proxsuite::nlp::python::OwningNonOwningHolder<
+          aligator::python::PyStageFunction<
+              aligator::context::IntegratorAbstract>> {
+  using OwningNonOwningHolder::OwningNonOwningHolder;
+};
+
+template <>
+struct value_holder<aligator::python::PyUnaryFunction<>>
+    : proxsuite::nlp::python::OwningNonOwningHolder<
+          aligator::python::PyUnaryFunction<>> {
+  using OwningNonOwningHolder::OwningNonOwningHolder;
+};
+
+} // namespace boost::python::objects

bindings/python/include/aligator/python/fwd.hpp

@@ -6,6 +6,8 @@
 #include <eigenpy/eigenpy.hpp>
 #include <eigenpy/std-vector.hpp>
 
+#include <proxsuite-nlp/python/polymorphic.hpp>
+
 namespace aligator {
 /// @brief  The Python bindings.
 namespace python {

bindings/python/include/aligator/python/modelling/continuous.hpp

@@ -4,18 +4,22 @@
 
 #include "aligator/python/fwd.hpp"
 
+#include "aligator/modelling/dynamics/context.hpp"
 #include "aligator/modelling/dynamics/continuous-dynamics-abstract.hpp"
 #include "aligator/modelling/dynamics/ode-abstract.hpp"
 
+#include "proxsuite-nlp/python/polymorphic.hpp"
+
 namespace aligator {
 namespace python {
 
-template <class T = dynamics::ContinuousDynamicsAbstractTpl<context::Scalar>>
-struct PyContinuousDynamics : T, bp::wrapper<T> {
-  using Data = dynamics::ContinuousDynamicsDataTpl<context::Scalar>;
+template <class T = context::ContinuousDynamicsAbstract>
+struct PyContinuousDynamics final
+    : T,
+      proxsuite::nlp::python::PolymorphicWrapper<PyContinuousDynamics<T>, T> {
+  using Data = context::ContinuousDynamicsData;
   ALIGATOR_DYNAMIC_TYPEDEFS(context::Scalar);
-
-  template <class... Args> PyContinuousDynamics(Args &&...args) : T(args...) {}
+  using T::T;
 
   void evaluate(const ConstVectorRef &x, const ConstVectorRef &u,
                 const ConstVectorRef &xdot, Data &data) const override {
@@ -36,21 +40,23 @@ struct PyContinuousDynamics : T, bp::wrapper<T> {
   shared_ptr<Data> default_createData() const { return T::createData(); }
 };
 
-template <class T = dynamics::ODEAbstractTpl<context::Scalar>>
-struct PyODEAbstract : T, bp::wrapper<T> {
+template <class T = context::ODEAbstract>
+struct PyODEAbstract final
+    : T,
+      proxsuite::nlp::python::PolymorphicWrapper<PyODEAbstract<T>, T> {
   using Scalar = context::Scalar;
   ALIGATOR_DYNAMIC_TYPEDEFS(Scalar);
-  using Data = dynamics::ContinuousDynamicsDataTpl<context::Scalar>;
+  using Data = context::ODEData;
 
-  template <class... Args> PyODEAbstract(Args &&...args) : T(args...) {}
+  using T::T;
 
-  virtual void forward(const ConstVectorRef &x, const ConstVectorRef &u,
-                       Data &data) const override {
+  void forward(const ConstVectorRef &x, const ConstVectorRef &u,
+               Data &data) const override {
     ALIGATOR_PYTHON_OVERRIDE_PURE(void, "forward", x, u, boost::ref(data));
   }
 
-  virtual void dForward(const ConstVectorRef &x, const ConstVectorRef &u,
-                        Data &data) const override {
+  void dForward(const ConstVectorRef &x, const ConstVectorRef &u,
+                Data &data) const override {
     ALIGATOR_PYTHON_OVERRIDE_PURE(void, "dForward", x, u, boost::ref(data));
   }
 
@@ -63,3 +69,21 @@ struct PyODEAbstract : T, bp::wrapper<T> {
 
 } // namespace python
 } // namespace aligator
+//
+namespace boost::python::objects {
+
+template <>
+struct value_holder<aligator::python::PyContinuousDynamics<>>
+    : proxsuite::nlp::python::OwningNonOwningHolder<
+          aligator::python::PyContinuousDynamics<>> {
+  using OwningNonOwningHolder::OwningNonOwningHolder;
+};
+
+template <>
+struct value_holder<aligator::python::PyODEAbstract<>>
+    : proxsuite::nlp::python::OwningNonOwningHolder<
+          aligator::python::PyODEAbstract<>> {
+  using OwningNonOwningHolder::OwningNonOwningHolder;
+};
+
+} // namespace boost::python::objects