Merge pull request #90 from Simple-Robotics/topic/manifold-polymorphic-value

[API breaking] Use polymorphic value type holder for manifolds and constraint sets

Author: ManifoldFR

CHANGELOG.md

@@ -8,15 +8,33 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 
 ### Added
-- Allow use of installed jrl-cmakemodules & eigenrand ([#106](https://github.com/Simple-Robotics/proxsuite-nlp/pull/106))
+
+* Add compatibility with jrl-cmakemodules workspace ([#99](https://github.com/Simple-Robotics/proxsuite-nlp/pull/99))
+* Add the `polymorphic_cxx14.hpp` header from [jbcoe/value_types](https://github.com/jbcoe/value_types/blob/main/polymorphic_cxx14.h), [#90](https://github.com/Simple-Robotics/proxsuite-nlp/pull/90)
+* **Python:** add conversions (for values, versions) for the `polymorphic<T,A>` types in new `<proxsuite-nlp/python/polymorphic.hpp>` header
+* **Python:** add `PolymorphicVisitor` visitor and `register_polymorphic_to_python<T>()` template function to register conversions from/to the `polymorphic<T, A>` type
+* Allow use of installed jrl-cmakemodules & eigenrand ([#106](https://github.com/Simple-Robotics/proxsuite-nlp/pull/106))
+
+### Changed
+
+* Change from `shared_ptr<T>` to `polymorphic<T>` for manifolds and constraint sets
+* Remove use of `std::make_shared` for manifolds in examples [#90](https://github.com/Simple-Robotics/proxsuite-nlp/pull/90), instead plass pain types
+* `ConstraintObjectTpl` now holds the constraint set through a `polymorphic<ConstraintSet>`
+* Changed ctors of `ProblemTpl` and `CostAbstractTpl` to template which takes the concrete manifold type
+* **Python:** pull all wrapper classes (inheriting from `bp::wrapper<U>`) out of the `aligator::python::internal` namespace
+* **Python:** fix abstract classes exposed as subclasses of `bp::wrapper<U>` not registering their owning `PyObject*` properly
+* Removed function template `allocate_shared_eigen_aligned` since we now use C++17 and Eigen::aligned_allocator is no longer needed.
+* Remove redundant macro `PROXSUITE_NLP_DEFINE_MANIFOLD_TYPES` and `PointType/TangentVectorType` typedefs in manifold API
 
 ## [0.7.1] - 2024-09-04
 
 ### Added
-- Add compatibility with jrl-cmakemodules workspace ([#99](https://github.com/Simple-Robotics/proxsuite-nlp/pull/99))
+* Add compatibility with jrl-cmakemodules workspace ([#99](https://github.com/Simple-Robotics/proxsuite-nlp/pull/99))
 
 ### Fixed
-- Remove CMake CMP0167 and CMP0169 warnings ([#100](https://github.com/Simple-Robotics/proxsuite-nlp/pull/100))
+
+* Remove CMake CMP0167 and CMP0169 warnings ([#100](https://github.com/Simple-Robotics/proxsuite-nlp/pull/100))
+
 
 ## [0.7.0] - 2024-05-14
 

bindings/python/CMakeLists.txt

@@ -1,5 +1,5 @@
 #
-# Copyright (C) 2022 LAAS-CNRS, INRIA
+# Copyright (C) 2022-2024 LAAS-CNRS, INRIA
 #
 
 # use underscore for Python to parse module name

bindings/python/expose-cartesian-product.cpp

@@ -1,14 +1,15 @@
 #include "proxsuite-nlp/modelling/spaces/cartesian-product.hpp"
 
 #include "proxsuite-nlp/python/fwd.hpp"
+#include "proxsuite-nlp/python/polymorphic.hpp"
 
 namespace proxsuite {
 namespace nlp {
 namespace python {
 
 using context::Manifold;
 using context::Scalar;
-using ManifoldPtr = shared_ptr<Manifold>;
+using PolymorphicManifold = polymorphic<Manifold>;
 using context::ConstVectorRef;
 using context::VectorRef;
 using context::VectorXs;
@@ -31,12 +32,14 @@ void exposeCartesianProduct() {
   using MutSplitSig =
       std::vector<VectorRef> (CartesianProduct::*)(VectorRef) const;
 
-  bp::class_<CartesianProduct, bp::bases<Manifold>,
-             shared_ptr<CartesianProduct>>(
+  bp::class_<CartesianProduct, bp::bases<Manifold>>(
       "CartesianProduct", "Cartesian product of two or more manifolds.",
-      bp::init<const std::vector<ManifoldPtr> &>(bp::args("self", "spaces")))
-      .def(
-          bp::init<ManifoldPtr, ManifoldPtr>(bp::args("self", "left", "right")))
+      bp::no_init)
+      .def(bp::init<>("self"_a))
+      .def(bp::init<const std::vector<PolymorphicManifold> &>(
+          ("self"_a, "spaces")))
+      .def(bp::init<PolymorphicManifold, PolymorphicManifold>(
+          ("self"_a, "left", "right")))
       .def(
           "getComponent",
           +[](CartesianProduct const &m, std::size_t i) -> const Manifold & {
@@ -46,28 +49,20 @@ void exposeCartesianProduct() {
             }
             return m.getComponent(i);
           },
-          bp::return_internal_reference<>(), bp::args("self", "i"),
+          bp::return_internal_reference<>(), ("self"_a, "i"),
           "Get the i-th component of the Cartesian product.")
-      .def(
-          "addComponent",
-          +[](CartesianProduct &m, ManifoldPtr const &p) { m.addComponent(p); },
-          bp::args("self", "c"), "Add a component to the Cartesian product.")
-      .def(
-          "addComponent",
-          +[](CartesianProduct &m, shared_ptr<CartesianProduct> const &p) {
-            m.addComponent(p);
-          },
-          bp::args("self", "c"), "Add a component to the Cartesian product.")
+      .def("addComponent", &CartesianProduct::addComponent<PolymorphicManifold>,
+           ("self"_a, "c"), "Add a component to the Cartesian product.")
       .add_property("num_components", &CartesianProduct::numComponents,
                     "Get the number of components in the Cartesian product.")
       .def(
           "split",
           +[](CartesianProduct const &m, const ConstVectorRef &x) {
             return copy_vec_constref(m.split(x));
           },
-          bp::args("self", "x"), split_doc.c_str())
+          ("self"_a, "x"), split_doc.c_str())
       .def<MutSplitSig>(
-          "split", &CartesianProduct::split, bp::args("self", "x"),
+          "split", &CartesianProduct::split, ("self"_a, "x"),
           (split_doc +
            " This returns a list of mutable references to each component.")
               .c_str())
@@ -76,23 +71,22 @@ void exposeCartesianProduct() {
           +[](CartesianProduct const &m, const ConstVectorRef &x) {
             return copy_vec_constref(m.split_vector(x));
           },
-          bp::args("self", "v"), split_vec_doc.c_str())
+          ("self"_a, "v"), split_vec_doc.c_str())
       .def<MutSplitSig>(
-          "split_vector", &CartesianProduct::split_vector,
-          bp::args("self", "v"),
+          "split_vector", &CartesianProduct::split_vector, ("self"_a, "v"),
           (split_vec_doc +
            " This returns a list of mutable references to each component.")
               .c_str())
-      .def("merge", &CartesianProduct::merge, bp::args("self", "xs"),
+      .def("merge", &CartesianProduct::merge, ("self"_a, "xs"),
            "Define a point on the manifold by merging points from each "
            "component.")
-      .def("merge_vector", &CartesianProduct::merge_vector,
-           bp::args("self", "vs"),
+      .def("merge_vector", &CartesianProduct::merge_vector, ("self"_a, "vs"),
            "Define a tangent vector on the manifold by merging vectors from "
            "each component.")
       .def(
-          "__mul__", +[](const shared_ptr<CartesianProduct> &a,
-                         const ManifoldPtr &b) { return a * b; });
+          "__mul__", +[](const CartesianProduct &a,
+                         const CartesianProduct &b) { return a * b; })
+      .def(PolymorphicVisitor<PolymorphicManifold>());
 }
 
 } // namespace python

bindings/python/expose-constraint.cpp

@@ -1,10 +1,12 @@
 /// @copyright Copyright (C) 2022 LAAS-CNRS, INRIA
-#include "proxsuite-nlp/python/fwd.hpp"
-
 #include "proxsuite-nlp/modelling/constraints.hpp"
 
+#include "proxsuite-nlp/python/polymorphic.hpp"
+
 #include <eigenpy/std-vector.hpp>
 
+#include <vector>
+
 namespace proxsuite {
 namespace nlp {
 namespace python {
@@ -21,67 +23,66 @@ using BoxConstraint = BoxConstraintTpl<Scalar>;
 
 template <typename T>
 auto exposeSpecificConstraintSet(const char *name, const char *docstring) {
-  return bp::class_<T, bp::bases<context::ConstraintSet>>(name, docstring,
-                                                          bp::no_init);
+  return bp::class_<T, bp::bases<ConstraintSet>>(name, docstring, bp::no_init)
+      .def(PolymorphicVisitor<polymorphic<ConstraintSet>>());
 }
 
-template <typename T>
+template <typename ConstraintType>
 context::Constraint make_constraint(const shared_ptr<context::C2Function> &f) {
-  return context::Constraint(f, std::make_shared<T>());
+  return context::Constraint(f, ConstraintType{});
 }
 
 static void exposeConstraintTypes();
 
 /// @todo Expose properly using pure_virtual, to allow overriding from Python
 void exposeConstraints() {
 
-  bp::register_ptr_to_python<shared_ptr<ConstraintSet>>();
+  register_polymorphic_to_python<polymorphic<ConstraintSet>>();
   bp::class_<ConstraintSet, boost::noncopyable>(
       "ConstraintSetBase",
       "Base class for constraint sets or nonsmooth penalties.", bp::no_init)
-      .def("evaluate", &ConstraintSet::evaluate, bp::args("self", "z"),
+      .def("evaluate", &ConstraintSet::evaluate, ("self"_a, "z"),
            "Evaluate the constraint indicator function or nonsmooth penalty "
            "on the projection/prox map of :math:`z`.")
-      .def("projection", &ConstraintSet::projection,
-           bp::args("self", "z", "zout"))
+      .def("projection", &ConstraintSet::projection, ("self"_a, "z", "zout"))
       .def(
           "projection",
           +[](const ConstraintSet &c, const ConstVectorRef &z) {
             context::VectorXs zout(z.size());
             c.projection(z, zout);
             return zout;
           },
-          bp::args("self", "z"))
+          ("self"_a, "z"))
       .def("normalConeProjection", &ConstraintSet::normalConeProjection,
-           bp::args("self", "z", "zout"))
+           ("self"_a, "z", "zout"))
       .def(
           "normalConeProjection",
           +[](const ConstraintSet &c, const ConstVectorRef &z) {
             context::VectorXs zout(z.size());
             c.normalConeProjection(z, zout);
             return zout;
           },
-          bp::args("self", "z"))
+          ("self"_a, "z"))
       .def("applyProjectionJacobian", &ConstraintSet::applyProjectionJacobian,
-           bp::args("self", "z", "Jout"), "Apply the projection Jacobian.")
+           ("self"_a, "z", "Jout"), "Apply the projection Jacobian.")
       .def("applyNormalProjectionJacobian",
            &ConstraintSet::applyNormalConeProjectionJacobian,
-           bp::args("self", "z", "Jout"),
+           ("self"_a, "z", "Jout"),
            "Apply the normal cone projection Jacobian.")
       .def("computeActiveSet", &ConstraintSet::computeActiveSet,
-           bp::args("self", "z", "out"))
+           ("self"_a, "z", "out"))
       .def("evaluateMoreauEnvelope", &ConstraintSet::evaluateMoreauEnvelope,
-           bp::args("self", "zin", "zproj"),
+           ("self"_a, "zin", "zproj"),
            "Evaluate the Moreau envelope with parameter :math:`\\mu`.")
       .def("setProxParameter", &ConstraintSet::setProxParameter,
-           bp::args("self", "mu"), "Set proximal parameter.")
+           ("self"_a, "mu"), "Set proximal parameter.")
       .add_property("mu", &ConstraintSet::mu, "Current proximal parameter.")
       .def(bp::self == bp::self);
 
   bp::class_<Constraint>(
       "ConstraintObject", "Packs a constraint set together with a function.",
-      bp::init<shared_ptr<C2Function>, shared_ptr<ConstraintSet>>(
-          bp::args("self", "func", "set")))
+      bp::init<shared_ptr<C2Function>, const polymorphic<ConstraintSet> &>(
+          ("self"_a, "func", "constraint_set")))
       .add_property("nr", &Constraint::nr, "Constraint dimension.")
       .def_readonly("func", &Constraint::func_, "Underlying function.")
       .def_readonly("set", &Constraint::set_, "Constraint set.");
@@ -125,7 +126,8 @@ static void exposeConstraintTypes() {
 
   exposeSpecificConstraintSet<ConstraintSetProduct>(
       "ConstraintSetProduct", "Cartesian product of constraint sets.")
-      .def(bp::init<std::vector<ConstraintSet *>, std::vector<Eigen::Index>>(
+      .def(bp::init<std::vector<polymorphic<ConstraintSet>>,
+                    std::vector<Eigen::Index>>(
           ("self"_a, "components", "blockSizes")))
       .add_property("components",
                     bp::make_function(&ConstraintSetProduct::components,
@@ -134,6 +136,11 @@ static void exposeConstraintTypes() {
                     bp::make_function(&ConstraintSetProduct::blockSizes,
                                       bp::return_internal_reference<>()),
                     "Dimensions of each component of the cartesian product.");
+
+  StdVectorPythonVisitor<std::vector<polymorphic<ConstraintSet>>>::expose(
+      "StdVec_ConstraintObject",
+      eigenpy::details::overload_base_get_item_for_std_vector<
+          std::vector<polymorphic<ConstraintSet>>>());
 }
 
 } // namespace python

bindings/python/expose-ldlt.cpp

@@ -1,5 +1,4 @@
 #include "proxsuite-nlp/python/fwd.hpp"
-#include "proxsuite-nlp/python/policies.hpp"
 
 #include "proxsuite-nlp/ldlt-allocator.hpp"
 
@@ -29,13 +28,13 @@ struct LDLTVisitor : bp::def_visitor<LDLTVisitor<LDLTtype>> {
   }
 
   template <typename... Args> void visit(bp::class_<Args...> &cl) const {
-    cl.def("compute", compute_proxy, policies::return_internal_reference,
+    cl.def("compute", compute_proxy, bp::return_internal_reference<>(),
            ("self"_a, "mat"))
         .def("solveInPlace", solveInPlace_proxy, ("self"_a, "rhsAndX"))
         .def("solve", solve<Eigen::Ref<const VectorXs>>, ("self"_a, "rhs"))
         .def("solve", solve<Eigen::Ref<const MatrixXs>>, ("self"_a, "rhs"))
-        .def("matrixLDLT", &LDLTtype::matrixLDLT, policies::return_by_value,
-             "self"_a,
+        .def("matrixLDLT", &LDLTtype::matrixLDLT,
+             bp::return_value_policy<bp::return_by_value>(), "self"_a,
              "Get the current value of the decomposition matrix. This makes a "
              "copy.");
   }