include/eigenpy/decompositions/sparse/SparseSolverBase.hpp

+/*
+ * Copyright 2024 INRIA
+ */
+
+#ifndef __eigenpy_decompositions_sparse_sparse_solver_base_hpp__
+#define __eigenpy_decompositions_sparse_sparse_solver_base_hpp__
+
+#include "eigenpy/eigenpy.hpp"
+#include "eigenpy/eigen/EigenBase.hpp"
+
+#include <Eigen/SparseCholesky>
+
+namespace eigenpy {
+
+template <typename SimplicialDerived>
+struct SparseSolverBaseVisitor
+    : public boost::python::def_visitor<
+          SparseSolverBaseVisitor<SimplicialDerived> > {
+  typedef SimplicialDerived Solver;
+
+  typedef typename SimplicialDerived::MatrixType MatrixType;
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+
+  typedef Eigen::Matrix<Scalar, Eigen::Dynamic, 1, MatrixType::Options>
+      DenseVectorXs;
+  typedef Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic,
+                        MatrixType::Options>
+      DenseMatrixXs;
+
+  template <class PyClass>
+  void visit(PyClass &cl) const {
+    cl.def("solve", &solve<DenseVectorXs>, bp::args("self", "b"),
+           "Returns the solution x of A x = b using the current "
+           "decomposition of A.")
+        .def("solve", &solve<DenseMatrixXs>, bp::args("self", "B"),
+             "Returns the solution X of A X = B using the current "
+             "decomposition of A where B is a right hand side matrix.")
+
+        .def("solve", &solve<MatrixType>, bp::args("self", "B"),
+             "Returns the solution X of A X = B using the current "
+             "decomposition of A where B is a right hand side matrix.");
+  }
+
+ private:
+  template <typename MatrixOrVector>
+  static MatrixOrVector solve(const Solver &self, const MatrixOrVector &vec) {
+    return self.solve(vec);
+  }
+};
+
+}  // namespace eigenpy
+
+#endif  // ifndef __eigenpy_decompositions_sparse_sparse_solver_base_hpp__

include/eigenpy/decompositions/sparse/accelerate/accelerate.hpp

+/*
+ * Copyright 2024 INRIA
+ */
+
+#ifndef __eigenpy_decomposition_sparse_accelerate_accelerate_hpp__
+#define __eigenpy_decomposition_sparse_accelerate_accelerate_hpp__
+
+#include "eigenpy/eigenpy.hpp"
+#include "eigenpy/eigen/EigenBase.hpp"
+#include "eigenpy/decompositions/sparse/SparseSolverBase.hpp"
+
+#include <Eigen/AccelerateSupport>
+
+namespace eigenpy {
+
+template <typename AccelerateDerived>
+struct AccelerateImplVisitor : public boost::python::def_visitor<
+                                   AccelerateImplVisitor<AccelerateDerived> > {
+  typedef AccelerateDerived Solver;
+
+  typedef typename AccelerateDerived::MatrixType MatrixType;
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  typedef MatrixType CholMatrixType;
+  typedef typename MatrixType::StorageIndex StorageIndex;
+
+  template <class PyClass>
+  void visit(PyClass &cl) const {
+    cl
+
+        .def("analyzePattern", &Solver::analyzePattern,
+             bp::args("self", "matrix"),
+             "Performs a symbolic decomposition on the sparcity of matrix.\n"
+             "This function is particularly useful when solving for several "
+             "problems having the same structure.")
+
+        .def(EigenBaseVisitor<Solver>())
+        .def(SparseSolverBaseVisitor<Solver>())
+
+        .def("compute",
+             (Solver & (Solver::*)(const MatrixType &matrix)) & Solver::compute,
+             bp::args("self", "matrix"),
+             "Computes the sparse Cholesky decomposition of a given matrix.",
+             bp::return_self<>())
+
+        .def("factorize", &Solver::factorize, bp::args("self", "matrix"),
+             "Performs a numeric decomposition of a given matrix.\n"
+             "The given matrix must has the same sparcity than the matrix on "
+             "which the symbolic decomposition has been performed.\n"
+             "See also analyzePattern().")
+
+        .def("info", &Solver::info, bp::arg("self"),
+             "NumericalIssue if the input contains INF or NaN values or "
+             "overflow occured. Returns Success otherwise.")
+
+        .def("setOrder", &Solver::setOrder, bp::arg("self"), "Set order");
+  }
+
+  static void expose(const std::string &name, const std::string &doc = "") {
+    bp::class_<Solver, boost::noncopyable>(name.c_str(), doc.c_str(),
+                                           bp::no_init)
+        .def(AccelerateImplVisitor())
+
+        .def(bp::init<>(bp::arg("self"), "Default constructor"))
+        .def(bp::init<MatrixType>(bp::args("self", "matrix"),
+                                  "Constructs and performs the "
+                                  "factorization from a given matrix."));
+  }
+};
+
+}  // namespace eigenpy
+
+#endif  // ifndef __eigenpy_decomposition_sparse_accelerate_accelerate_hpp__

include/eigenpy/decompositions/sparse/cholmod/CholmodBase.hpp

+/*
+ * Copyright 2024 INRIA
+ */
+
+#ifndef __eigenpy_decomposition_sparse_cholmod_cholmod_base_hpp__
+#define __eigenpy_decomposition_sparse_cholmod_cholmod_base_hpp__
+
+#include "eigenpy/eigenpy.hpp"
+#include "eigenpy/eigen/EigenBase.hpp"
+#include "eigenpy/decompositions/sparse/SparseSolverBase.hpp"
+
+#include <Eigen/CholmodSupport>
+
+namespace eigenpy {
+
+template <typename CholdmodDerived>
+struct CholmodBaseVisitor
+    : public boost::python::def_visitor<CholmodBaseVisitor<CholdmodDerived> > {
+  typedef CholdmodDerived Solver;
+
+  typedef typename CholdmodDerived::MatrixType MatrixType;
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+  typedef MatrixType CholMatrixType;
+  typedef typename MatrixType::StorageIndex StorageIndex;
+
+  template <class PyClass>
+  void visit(PyClass &cl) const {
+    cl.def("analyzePattern", &Solver::analyzePattern,
+           bp::args("self", "matrix"),
+           "Performs a symbolic decomposition on the sparcity of matrix.\n"
+           "This function is particularly useful when solving for several "
+           "problems having the same structure.")
+
+        .def(EigenBaseVisitor<Solver>())
+        .def(SparseSolverBaseVisitor<Solver>())
+
+        .def("compute",
+             (Solver & (Solver::*)(const MatrixType &matrix)) & Solver::compute,
+             bp::args("self", "matrix"),
+             "Computes the sparse Cholesky decomposition of a given matrix.",
+             bp::return_self<>())
+
+        .def("determinant", &Solver::determinant, bp::arg("self"),
+             "Returns the determinant of the underlying matrix from the "
+             "current factorization.")
+
+        .def("factorize", &Solver::factorize, bp::args("self", "matrix"),
+             "Performs a numeric decomposition of a given matrix.\n"
+             "The given matrix must has the same sparcity than the matrix on "
+             "which the symbolic decomposition has been performed.\n"
+             "See also analyzePattern().")
+
+        .def("info", &Solver::info, bp::arg("self"),
+             "NumericalIssue if the input contains INF or NaN values or "
+             "overflow occured. Returns Success otherwise.")
+
+        .def("logDeterminant", &Solver::logDeterminant, bp::arg("self"),
+             "Returns the log determinant of the underlying matrix from the "
+             "current factorization.")
+
+        .def("setShift", &Solver::setShift, (bp::args("self", "offset")),
+             "Sets the shift parameters that will be used to adjust the "
+             "diagonal coefficients during the numerical factorization.\n"
+             "During the numerical factorization, the diagonal coefficients "
+             "are transformed by the following linear model: d_ii = offset + "
+             "d_ii.\n"
+             "The default is the identity transformation with offset=0.",
+             bp::return_self<>());
+  }
+};
+
+}  // namespace eigenpy
+
+#endif  // ifndef __eigenpy_decomposition_sparse_cholmod_cholmod_base_hpp__

include/eigenpy/decompositions/sparse/cholmod/CholmodDecomposition.hpp

+/*
+ * Copyright 2024 INRIA
+ */
+
+#ifndef __eigenpy_decomposition_sparse_cholmod_cholmod_decomposition_hpp__
+#define __eigenpy_decomposition_sparse_cholmod_cholmod_decomposition_hpp__
+
+#include "eigenpy/eigenpy.hpp"
+#include "eigenpy/decompositions/sparse/cholmod/CholmodBase.hpp"
+
+namespace eigenpy {
+
+template <typename CholdmodDerived>
+struct CholmodDecompositionVisitor
+    : public boost::python::def_visitor<
+          CholmodDecompositionVisitor<CholdmodDerived> > {
+  typedef CholdmodDerived Solver;
+
+  template <class PyClass>
+  void visit(PyClass &cl) const {
+    cl
+
+        .def(CholmodBaseVisitor<Solver>())
+        .def("setMode", &Solver::setMode, bp::args("self", "mode"),
+             "Set the mode for the Cholesky decomposition.");
+  }
+};
+
+}  // namespace eigenpy
+
+#endif  // ifndef
+        // __eigenpy_decomposition_sparse_cholmod_cholmod_decomposition_hpp__

include/eigenpy/decompositions/sparse/cholmod/CholmodSimplicialLDLT.hpp

+/*
+ * Copyright 2024 INRIA
+ */
+
+#ifndef __eigenpy_decomposition_sparse_cholmod_cholmod_simplicial_ldlt_hpp__
+#define __eigenpy_decomposition_sparse_cholmod_cholmod_simplicial_ldlt_hpp__
+
+#include "eigenpy/eigenpy.hpp"
+#include "eigenpy/decompositions/sparse/cholmod/CholmodDecomposition.hpp"
+#include "eigenpy/utils/scalar-name.hpp"
+
+namespace eigenpy {
+
+template <typename MatrixType_, int UpLo_ = Eigen::Lower>
+struct CholmodSimplicialLDLTVisitor
+    : public boost::python::def_visitor<
+          CholmodSimplicialLDLTVisitor<MatrixType_, UpLo_> > {
+  typedef MatrixType_ MatrixType;
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+
+  typedef Eigen::CholmodSimplicialLDLT<MatrixType_, UpLo_> Solver;
+
+  template <class PyClass>
+  void visit(PyClass &cl) const {
+    cl
+
+        .def(CholmodBaseVisitor<Solver>())
+        .def(bp::init<>(bp::arg("self"), "Default constructor"))
+        .def(bp::init<MatrixType>(bp::args("self", "matrix"),
+                                  "Constructs and performs the LDLT "
+                                  "factorization from a given matrix."))
+
+        ;
+  }
+
+  static void expose() {
+    static const std::string classname =
+        "CholmodSimplicialLDLT_" + scalar_name<Scalar>::shortname();
+    expose(classname);
+  }
+
+  static void expose(const std::string &name) {
+    bp::class_<Solver, boost::noncopyable>(
+        name.c_str(),
+        "A simplicial direct Cholesky (LDLT) factorization and solver based on "
+        "Cholmod.\n\n"
+        "This class allows to solve for A.X = B sparse linear problems via a "
+        "simplicial LL^T Cholesky factorization using the Cholmod library."
+        "This simplicial variant is equivalent to Eigen's built-in "
+        "SimplicialLDLT class."
+        "Therefore, it has little practical interest. The sparse matrix A must "
+        "be selfadjoint and positive definite."
+        "The vectors or matrices X and B can be either dense or sparse.",
+        bp::no_init)
+        .def(CholmodSimplicialLDLTVisitor());
+  }
+};
+
+}  // namespace eigenpy
+
+#endif  // ifndef
+        // __eigenpy_decomposition_sparse_cholmod_cholmod_simplicial_ldlt_hpp__

include/eigenpy/decompositions/sparse/cholmod/CholmodSimplicialLLT.hpp

+/*
+ * Copyright 2024 INRIA
+ */
+
+#ifndef __eigenpy_decomposition_sparse_cholmod_cholmod_simplicial_llt_hpp__
+#define __eigenpy_decomposition_sparse_cholmod_cholmod_simplicial_llt_hpp__
+
+#include "eigenpy/eigenpy.hpp"
+#include "eigenpy/decompositions/sparse/cholmod/CholmodDecomposition.hpp"
+#include "eigenpy/utils/scalar-name.hpp"
+
+namespace eigenpy {
+
+template <typename MatrixType_, int UpLo_ = Eigen::Lower>
+struct CholmodSimplicialLLTVisitor
+    : public boost::python::def_visitor<
+          CholmodSimplicialLLTVisitor<MatrixType_, UpLo_> > {
+  typedef MatrixType_ MatrixType;
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+
+  typedef Eigen::CholmodSimplicialLLT<MatrixType_, UpLo_> Solver;
+
+  template <class PyClass>
+  void visit(PyClass &cl) const {
+    cl
+
+        .def(CholmodBaseVisitor<Solver>())
+        .def(bp::init<>(bp::arg("self"), "Default constructor"))
+        .def(bp::init<MatrixType>(bp::args("self", "matrix"),
+                                  "Constructs and performs the LLT "
+                                  "factorization from a given matrix."))
+
+        ;
+  }
+
+  static void expose() {
+    static const std::string classname =
+        "CholmodSimplicialLLT_" + scalar_name<Scalar>::shortname();
+    expose(classname);
+  }
+
+  static void expose(const std::string &name) {
+    bp::class_<Solver, boost::noncopyable>(
+        name.c_str(),
+        "A simplicial direct Cholesky (LLT) factorization and solver based on "
+        "Cholmod.\n\n"
+        "This class allows to solve for A.X = B sparse linear problems via a "
+        "simplicial LL^T Cholesky factorization using the Cholmod library."
+        "This simplicial variant is equivalent to Eigen's built-in "
+        "SimplicialLLT class."
+        "Therefore, it has little practical interest. The sparse matrix A must "
+        "be selfadjoint and positive definite."
+        "The vectors or matrices X and B can be either dense or sparse.",
+        bp::no_init)
+        .def(CholmodSimplicialLLTVisitor());
+  }
+};
+
+}  // namespace eigenpy
+
+#endif  // ifndef
+        // __eigenpy_decomposition_sparse_cholmod_cholmod_simplicial_llt_hpp__

include/eigenpy/decompositions/sparse/cholmod/CholmodSupernodalLLT.hpp

+/*
+ * Copyright 2024 INRIA
+ */
+
+#ifndef __eigenpy_decomposition_sparse_cholmod_cholmod_supernodal_llt_hpp__
+#define __eigenpy_decomposition_sparse_cholmod_cholmod_supernodal_llt_hpp__
+
+#include "eigenpy/eigenpy.hpp"
+#include "eigenpy/decompositions/sparse/cholmod/CholmodDecomposition.hpp"
+#include "eigenpy/utils/scalar-name.hpp"
+
+namespace eigenpy {
+
+template <typename MatrixType_, int UpLo_ = Eigen::Lower>
+struct CholmodSupernodalLLTVisitor
+    : public boost::python::def_visitor<
+          CholmodSupernodalLLTVisitor<MatrixType_, UpLo_> > {
+  typedef MatrixType_ MatrixType;
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+
+  typedef Eigen::CholmodSupernodalLLT<MatrixType_, UpLo_> Solver;
+
+  template <class PyClass>
+  void visit(PyClass &cl) const {
+    cl
+
+        .def(CholmodBaseVisitor<Solver>())
+        .def(bp::init<>(bp::arg("self"), "Default constructor"))
+        .def(bp::init<MatrixType>(bp::args("self", "matrix"),
+                                  "Constructs and performs the LLT "
+                                  "factorization from a given matrix."))
+
+        ;
+  }
+
+  static void expose() {
+    static const std::string classname =
+        "CholmodSupernodalLLT_" + scalar_name<Scalar>::shortname();
+    expose(classname);
+  }
+
+  static void expose(const std::string &name) {
+    bp::class_<Solver, boost::noncopyable>(
+        name.c_str(),
+        "A supernodal direct Cholesky (LLT) factorization and solver based on "
+        "Cholmod.\n\n"
+        "This class allows to solve for A.X = B sparse linear problems via a "
+        "supernodal LL^T Cholesky factorization using the Cholmod library."
+        "This supernodal variant performs best on dense enough problems, e.g., "
+        "3D FEM, or very high order 2D FEM."
+        "The sparse matrix A must be selfadjoint and positive definite. The "
+        "vectors or matrices X and B can be either dense or sparse.",
+        bp::no_init)
+        .def(CholmodSupernodalLLTVisitor());
+  }
+};
+
+}  // namespace eigenpy
+
+#endif  // ifndef
+        // __eigenpy_decomposition_sparse_cholmod_cholmod_supernodal_llt_hpp__

include/eigenpy/deprecation-policy.hpp

+//
+// Copyright (C) 2020 INRIA
+// Copyright (C) 2024 LAAS-CNRS, INRIA
+//
+#ifndef __eigenpy_deprecation_hpp__
+#define __eigenpy_deprecation_hpp__
+
+#include "eigenpy/fwd.hpp"
+
+namespace eigenpy {
+
+enum class DeprecationType { DEPRECATION, FUTURE };
+
+namespace detail {
+
+inline PyObject *deprecationTypeToPyObj(DeprecationType dep) {
+  switch (dep) {
+    case DeprecationType::DEPRECATION:
+      return PyExc_DeprecationWarning;
+    case DeprecationType::FUTURE:
+      return PyExc_FutureWarning;
+    default:  // The switch handles all cases explicitly, this should never be
+              // triggered.
+      throw std::invalid_argument(
+          "Undefined DeprecationType - this should never be triggered.");
+  }
+}
+
+}  // namespace detail
+
+/// @brief A Boost.Python call policy which triggers a Python warning on
+/// precall.
+template <DeprecationType deprecation_type = DeprecationType::DEPRECATION,
+          class BasePolicy = bp::default_call_policies>
+struct deprecation_warning_policy : BasePolicy {
+  using result_converter = typename BasePolicy::result_converter;
+  using argument_package = typename BasePolicy::argument_package;
+
+  deprecation_warning_policy(const std::string &warning_msg)
+      : BasePolicy(), m_what(warning_msg) {}
+
+  std::string what() const { return m_what; }
+
+  const BasePolicy *derived() const {
+    return static_cast<const BasePolicy *>(this);
+  }
+
+  template <class ArgPackage>
+  bool precall(const ArgPackage &args) const {
+    PyErr_WarnEx(detail::deprecationTypeToPyObj(deprecation_type),
+                 m_what.c_str(), 1);
+    return derived()->precall(args);
+  }
+
+ protected:
+  const std::string m_what;
+};
+
+template <DeprecationType deprecation_type = DeprecationType::DEPRECATION,
+          class BasePolicy = bp::default_call_policies>
+struct deprecated_function
+    : deprecation_warning_policy<deprecation_type, BasePolicy> {
+  deprecated_function(const std::string &msg =
+                          "This function has been marked as deprecated, and "
+                          "will be removed in the future.")
+      : deprecation_warning_policy<deprecation_type, BasePolicy>(msg) {}
+};
+
+template <DeprecationType deprecation_type = DeprecationType::DEPRECATION,
+          class BasePolicy = bp::default_call_policies>
+struct deprecated_member
+    : deprecation_warning_policy<deprecation_type, BasePolicy> {
+  deprecated_member(const std::string &msg =
+                        "This attribute or method has been marked as "
+                        "deprecated, and will be removed in the future.")
+      : deprecation_warning_policy<deprecation_type, BasePolicy>(msg) {}
+};
+
+}  // namespace eigenpy
+
+#endif  // ifndef __eigenpy_deprecation_hpp__

include/eigenpy/details.hpp

 /*
  * Copyright 2014-2019, CNRS
- * Copyright 2018-2023, INRIA
+ * Copyright 2018-2024, INRIA
  */
 
 #ifndef __eigenpy_details_hpp__
@@ -17,24 +17,69 @@
 #include "eigenpy/scalar-conversion.hpp"
 
 namespace eigenpy {
-template <typename MatType, typename EigenEquivalentType>
-EIGENPY_DEPRECATED void enableEigenPySpecific() {
-  enableEigenPySpecific<MatType>();
-}
 
-template <typename MatType>
-void enableEigenPySpecific() {
-  if (check_registration<MatType>()) return;
+template <typename EigenType,
+          typename BaseType = typename get_eigen_base_type<EigenType>::type,
+          typename Scalar = typename EigenType::Scalar>
+struct expose_eigen_type_impl;
+
+template <typename MatType, typename Scalar>
+struct expose_eigen_type_impl<MatType, Eigen::MatrixBase<MatType>, Scalar> {
+  static void run() {
+    if (check_registration<MatType>()) return;
 
-  // to-python
-  EigenToPyConverter<MatType>::registration();
+    // to-python
+    EigenToPyConverter<MatType>::registration();
 #if EIGEN_VERSION_AT_LEAST(3, 2, 0)
-  EigenToPyConverter<Eigen::Ref<MatType> >::registration();
-  EigenToPyConverter<const Eigen::Ref<const MatType> >::registration();
+    EigenToPyConverter<Eigen::Ref<MatType> >::registration();
+    EigenToPyConverter<const Eigen::Ref<const MatType> >::registration();
+#endif
+
+    // from-python
+    EigenFromPyConverter<MatType>::registration();
+  }
+};
+
+template <typename MatType, typename Scalar>
+struct expose_eigen_type_impl<MatType, Eigen::SparseMatrixBase<MatType>,
+                              Scalar> {
+  static void run() {
+    if (check_registration<MatType>()) return;
+
+    // to-python
+    EigenToPyConverter<MatType>::registration();
+    // #if EIGEN_VERSION_AT_LEAST(3, 2, 0)
+    //     EigenToPyConverter<Eigen::Ref<MatType> >::registration();
+    //     EigenToPyConverter<const Eigen::Ref<const MatType> >::registration();
+    // #endif
+
+    // from-python
+    EigenFromPyConverter<MatType>::registration();
+  }
+};
+
+#ifdef EIGENPY_WITH_TENSOR_SUPPORT
+template <typename TensorType, typename Scalar>
+struct expose_eigen_type_impl<TensorType, Eigen::TensorBase<TensorType>,
+                              Scalar> {
+  static void run() {
+    if (check_registration<TensorType>()) return;
+
+    // to-python
+    EigenToPyConverter<TensorType>::registration();
+    EigenToPyConverter<Eigen::TensorRef<TensorType> >::registration();
+    EigenToPyConverter<
+        const Eigen::TensorRef<const TensorType> >::registration();
+
+    // from-python
+    EigenFromPyConverter<TensorType>::registration();
+  }
+};
 #endif
 
-  // from-python
-  EigenFromPyConverter<MatType>::registration();
+template <typename MatType>
+void enableEigenPySpecific() {
+  expose_eigen_type_impl<MatType>::run();
 }
 
 }  // namespace eigenpy

include/eigenpy/eigen-from-python.hpp

@@ -12,13 +12,12 @@
 
 namespace eigenpy {
 
-template <typename C>
+template <typename EigenType,
+          typename BaseType = typename get_eigen_base_type<EigenType>::type>
 struct expected_pytype_for_arg {};
 
-template <typename Scalar, int Rows, int Cols, int Options, int MaxRows,
-          int MaxCols>
-struct expected_pytype_for_arg<
-    Eigen::Matrix<Scalar, Rows, Cols, Options, MaxRows, MaxCols> > {
+template <typename MatType>
+struct expected_pytype_for_arg<MatType, Eigen::MatrixBase<MatType> > {
   static PyTypeObject const *get_pytype() {
     PyTypeObject const *py_type = eigenpy::getPyArrayType();
     return py_type;
@@ -59,44 +58,43 @@ struct copy_if_non_const<const MatType, true> {
 };
 
 #if EIGEN_VERSION_AT_LEAST(3, 2, 0)
-template <typename MatType, int Options, typename Stride>
-struct referent_storage_eigen_ref;
 
-template <typename MatType, int Options, typename Stride>
+template <typename _RefType>
 struct referent_storage_eigen_ref {
-  typedef Eigen::Ref<MatType, Options, Stride> RefType;
+  typedef _RefType RefType;
+  typedef typename get_eigen_plain_type<RefType>::type PlainObjectType;
   typedef typename ::eigenpy::aligned_storage<
       ::boost::python::detail::referent_size<RefType &>::value>::type
       AlignedStorage;
 
   referent_storage_eigen_ref()
       : pyArray(NULL),
-        mat_ptr(NULL),
+        plain_ptr(NULL),
         ref_ptr(reinterpret_cast<RefType *>(ref_storage.bytes)) {}
 
   referent_storage_eigen_ref(const RefType &ref, PyArrayObject *pyArray,
-                             MatType *mat_ptr = NULL)
+                             PlainObjectType *plain_ptr = NULL)
       : pyArray(pyArray),
-        mat_ptr(mat_ptr),
+        plain_ptr(plain_ptr),
         ref_ptr(reinterpret_cast<RefType *>(ref_storage.bytes)) {
     Py_INCREF(pyArray);
     new (ref_storage.bytes) RefType(ref);
   }
 
   ~referent_storage_eigen_ref() {
-    if (mat_ptr != NULL && PyArray_ISWRITEABLE(pyArray))
-      copy_if_non_const<MatType>::run(*mat_ptr, pyArray);
+    if (plain_ptr != NULL && PyArray_ISWRITEABLE(pyArray))
+      copy_if_non_const<PlainObjectType>::run(*plain_ptr, pyArray);
 
     Py_DECREF(pyArray);
 
-    if (mat_ptr != NULL) mat_ptr->~MatType();
+    if (plain_ptr != NULL) plain_ptr->~PlainObjectType();
 
     ref_ptr->~RefType();
   }
 
   AlignedStorage ref_storage;
   PyArrayObject *pyArray;
-  MatType *mat_ptr;
+  PlainObjectType *plain_ptr;
   RefType *ref_ptr;
 };
 #endif
@@ -110,18 +108,16 @@ namespace detail {
 #if EIGEN_VERSION_AT_LEAST(3, 2, 0)
 template <typename MatType, int Options, typename Stride>
 struct referent_storage<Eigen::Ref<MatType, Options, Stride> &> {
-  typedef ::eigenpy::details::referent_storage_eigen_ref<MatType, Options,
-                                                         Stride>
-      StorageType;
+  typedef Eigen::Ref<MatType, Options, Stride> RefType;
+  typedef ::eigenpy::details::referent_storage_eigen_ref<RefType> StorageType;
   typedef typename ::eigenpy::aligned_storage<
       referent_size<StorageType &>::value>::type type;
 };
 
 template <typename MatType, int Options, typename Stride>
 struct referent_storage<const Eigen::Ref<const MatType, Options, Stride> &> {
-  typedef ::eigenpy::details::referent_storage_eigen_ref<const MatType, Options,
-                                                         Stride>
-      StorageType;
+  typedef Eigen::Ref<const MatType, Options, Stride> RefType;
+  typedef ::eigenpy::details::referent_storage_eigen_ref<RefType> StorageType;
   typedef typename ::eigenpy::aligned_storage<
       referent_size<StorageType &>::value>::type type;
 };
@@ -173,7 +169,7 @@ struct rvalue_from_python_data<Eigen::PlainObjectBase<Derived> const &>
 template <typename MatType, int Options, typename Stride>
 struct rvalue_from_python_data<Eigen::Ref<MatType, Options, Stride> &>
     : rvalue_from_python_storage<Eigen::Ref<MatType, Options, Stride> &> {
-  typedef Eigen::Ref<MatType, Options, Stride> T;
+  typedef Eigen::Ref<MatType, Options, Stride> RefType;
 
 #if (!defined(__MWERKS__) || __MWERKS__ >= 0x3000) &&                        \
     (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= 245) &&                 \
@@ -181,7 +177,7 @@ struct rvalue_from_python_data<Eigen::Ref<MatType, Options, Stride> &>
     !defined(BOOST_PYTHON_SYNOPSIS) /* Synopsis' OpenCXX has trouble parsing \
                                        this */
   // This must always be a POD struct with m_data its first member.
-  BOOST_STATIC_ASSERT(BOOST_PYTHON_OFFSETOF(rvalue_from_python_storage<T>,
+  BOOST_STATIC_ASSERT(BOOST_PYTHON_OFFSETOF(rvalue_from_python_storage<RefType>,
                                             stage1) == 0);
 #endif
 
@@ -199,9 +195,7 @@ struct rvalue_from_python_data<Eigen::Ref<MatType, Options, Stride> &>
 
   // Destroys any object constructed in the storage.
   ~rvalue_from_python_data() {
-    typedef ::eigenpy::details::referent_storage_eigen_ref<MatType, Options,
-                                                           Stride>
-        StorageType;
+    typedef ::eigenpy::details::referent_storage_eigen_ref<RefType> StorageType;
     if (this->stage1.convertible == this->storage.bytes)
       static_cast<StorageType *>((void *)this->storage.bytes)->~StorageType();
   }
@@ -212,7 +206,7 @@ struct rvalue_from_python_data<
     const Eigen::Ref<const MatType, Options, Stride> &>
     : rvalue_from_python_storage<
           const Eigen::Ref<const MatType, Options, Stride> &> {
-  typedef const Eigen::Ref<const MatType, Options, Stride> T;
+  typedef Eigen::Ref<const MatType, Options, Stride> RefType;
 
 #if (!defined(__MWERKS__) || __MWERKS__ >= 0x3000) &&                        \
     (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= 245) &&                 \
@@ -220,7 +214,7 @@ struct rvalue_from_python_data<
     !defined(BOOST_PYTHON_SYNOPSIS) /* Synopsis' OpenCXX has trouble parsing \
                                        this */
   // This must always be a POD struct with m_data its first member.
-  BOOST_STATIC_ASSERT(BOOST_PYTHON_OFFSETOF(rvalue_from_python_storage<T>,
+  BOOST_STATIC_ASSERT(BOOST_PYTHON_OFFSETOF(rvalue_from_python_storage<RefType>,
                                             stage1) == 0);
 #endif
 
@@ -238,9 +232,7 @@ struct rvalue_from_python_data<
 
   // Destroys any object constructed in the storage.
   ~rvalue_from_python_data() {
-    typedef ::eigenpy::details::referent_storage_eigen_ref<const MatType,
-                                                           Options, Stride>
-        StorageType;
+    typedef ::eigenpy::details::referent_storage_eigen_ref<RefType> StorageType;
     if (this->stage1.convertible == this->storage.bytes)
       static_cast<StorageType *>((void *)this->storage.bytes)->~StorageType();
   }
@@ -269,8 +261,23 @@ void eigen_from_py_construct(
   memory->convertible = storage->storage.bytes;
 }
 
-template <typename MatType, typename _Scalar>
-struct EigenFromPy {
+template <typename EigenType,
+          typename BaseType = typename get_eigen_base_type<EigenType>::type>
+struct eigen_from_py_impl {
+  typedef typename EigenType::Scalar Scalar;
+
+  /// \brief Determine if pyObj can be converted into a MatType object
+  static void *convertible(PyObject *pyObj);
+
+  /// \brief Allocate memory and copy pyObj in the new storage
+  static void construct(PyObject *pyObj,
+                        bp::converter::rvalue_from_python_stage1_data *memory);
+
+  static void registration();
+};
+
+template <typename MatType>
+struct eigen_from_py_impl<MatType, Eigen::MatrixBase<MatType> > {
   typedef typename MatType::Scalar Scalar;
 
   /// \brief Determine if pyObj can be converted into a MatType object
@@ -283,8 +290,14 @@ struct EigenFromPy {
   static void registration();
 };
 
-template <typename MatType, typename _Scalar>
-void *EigenFromPy<MatType, _Scalar>::convertible(PyObject *pyObj) {
+template <typename EigenType,
+          typename Scalar =
+              typename boost::remove_reference<EigenType>::type::Scalar>
+struct EigenFromPy : eigen_from_py_impl<EigenType> {};
+
+template <typename MatType>
+void *eigen_from_py_impl<MatType, Eigen::MatrixBase<MatType> >::convertible(
+    PyObject *pyObj) {
   if (!call_PyArray_Check(reinterpret_cast<PyObject *>(pyObj))) return 0;
 
   PyArrayObject *pyArray = reinterpret_cast<PyArrayObject *>(pyObj);
@@ -384,26 +397,33 @@ void *EigenFromPy<MatType, _Scalar>::convertible(PyObject *pyObj) {
   return pyArray;
 }
 
-template <typename MatType, typename _Scalar>
-void EigenFromPy<MatType, _Scalar>::construct(
+template <typename MatType>
+void eigen_from_py_impl<MatType, Eigen::MatrixBase<MatType> >::construct(
     PyObject *pyObj, bp::converter::rvalue_from_python_stage1_data *memory) {
   eigen_from_py_construct<MatType>(pyObj, memory);
 }
 
-template <typename MatType, typename _Scalar>
-void EigenFromPy<MatType, _Scalar>::registration() {
+template <typename MatType>
+void eigen_from_py_impl<MatType, Eigen::MatrixBase<MatType> >::registration() {
   bp::converter::registry::push_back(
-      reinterpret_cast<void *(*)(_object *)>(&EigenFromPy::convertible),
-      &EigenFromPy::construct, bp::type_id<MatType>()
+      reinterpret_cast<void *(*)(_object *)>(&eigen_from_py_impl::convertible),
+      &eigen_from_py_impl::construct, bp::type_id<MatType>()
 #ifndef BOOST_PYTHON_NO_PY_SIGNATURES
-                                   ,
+                                          ,
       &eigenpy::expected_pytype_for_arg<MatType>::get_pytype
 #endif
   );
 }
 
+template <typename EigenType,
+          typename BaseType = typename get_eigen_base_type<EigenType>::type>
+struct eigen_from_py_converter_impl;
+
+template <typename EigenType>
+struct EigenFromPyConverter : eigen_from_py_converter_impl<EigenType> {};
+
 template <typename MatType>
-struct EigenFromPyConverter {
+struct eigen_from_py_converter_impl<MatType, Eigen::MatrixBase<MatType> > {
   static void registration() {
     EigenFromPy<MatType>::registration();
 
@@ -535,4 +555,10 @@ struct EigenFromPy<const Eigen::Ref<const MatType, Options, Stride> > {
 
 }  // namespace eigenpy
 
+#ifdef EIGENPY_WITH_TENSOR_SUPPORT
+#include "eigenpy/tensor/eigen-from-python.hpp"
+#endif
+
+#include "eigenpy/sparse/eigen-from-python.hpp"
+
 #endif  // __eigenpy_eigen_from_python_hpp__

include/eigenpy/eigen-typedef.hpp

 //
-// Copyright (c) 2020 INRIA
+// Copyright (c) 2020-2023 INRIA
 //
 
 #ifndef __eigenpy_eigen_typedef_hpp__
@@ -31,6 +31,8 @@
   EIGENPY_MAKE_TYPEDEFS(Type, Options, TypeSuffix, Eigen::Dynamic, X) \
   EIGENPY_MAKE_FIXED_TYPEDEFS(Type, Options, TypeSuffix, 2)           \
   EIGENPY_MAKE_FIXED_TYPEDEFS(Type, Options, TypeSuffix, 3)           \
-  EIGENPY_MAKE_FIXED_TYPEDEFS(Type, Options, TypeSuffix, 4)
+  EIGENPY_MAKE_FIXED_TYPEDEFS(Type, Options, TypeSuffix, 4)           \
+  EIGENPY_MAKE_TYPEDEFS(Type, Options, TypeSuffix, 1, 1)              \
+  typedef Eigen::SparseMatrix<Scalar, Options> SparseMatrixX##TypeSuffix
 
 #endif  // ifndef __eigenpy_eigen_typedef_hpp__

include/eigenpy/eigen/EigenBase.hpp

+/*
+ * Copyright 2024 INRIA
+ */
+
+#ifndef __eigenpy_eigen_eigen_base_hpp__
+#define __eigenpy_eigen_eigen_base_hpp__
+
+#include "eigenpy/eigenpy.hpp"
+
+namespace eigenpy {
+
+template <typename Derived>
+struct EigenBaseVisitor
+    : public boost::python::def_visitor<EigenBaseVisitor<Derived> > {
+  template <class PyClass>
+  void visit(PyClass &cl) const {
+    cl.def("cols", &Derived::cols, bp::arg("self"),
+           "Returns the number of columns.")
+        .def("rows", &Derived::rows, bp::arg("self"),
+             "Returns the number of rows.")
+        .def("size", &Derived::rows, bp::arg("self"),
+             "Returns the number of coefficients, which is rows()*cols().");
+  }
+};
+
+}  // namespace eigenpy
+
+#endif  // ifndef __eigenpy_eigen_eigen_base_hpp__

include/eigenpy/eigenpy.hpp

 /*
  * Copyright 2014-2019, CNRS
- * Copyright 2018-2020, INRIA
+ * Copyright 2018-2024, INRIA
  */
 
 #ifndef __eigenpy_eigenpy_hpp__
 #define __eigenpy_eigenpy_hpp__
 
 #include "eigenpy/fwd.hpp"
-#include "eigenpy/deprecated.hpp"
 #include "eigenpy/eigen-typedef.hpp"
+#include "eigenpy/expose.hpp"
+
+/// Custom CallPolicies
+#include "eigenpy/std-unique-ptr.hpp"
 
 #define ENABLE_SPECIFIC_MATRIX_TYPE(TYPE) \
   ::eigenpy::enableEigenPySpecific<TYPE>();
@@ -19,22 +22,20 @@ namespace eigenpy {
  */
 void EIGENPY_DLLAPI enableEigenPy();
 
-/* Enable the Eigen--Numpy serialization for the templated MatrixBase class.
- * The second template argument is used for inheritance of Eigen classes. If
- * using a native Eigen::MatrixBase, simply repeat the same arg twice. */
+bool EIGENPY_DLLAPI withTensorSupport();
+
+/* Enable the Eigen--Numpy serialization for the templated MatType class.*/
 template <typename MatType>
 void enableEigenPySpecific();
 
-/* Enable the Eigen--Numpy serialization for the templated MatrixBase class.
- * The second template argument is used for inheritance of Eigen classes. If
- * using a native Eigen::MatrixBase, simply repeat the same arg twice. */
-template <typename MatType, typename EigenEquivalentType>
-EIGENPY_DEPRECATED void enableEigenPySpecific();
-
 template <typename Scalar, int Options>
 EIGEN_DONT_INLINE void exposeType() {
   EIGENPY_MAKE_TYPEDEFS_ALL_SIZES(Scalar, Options, s);
 
+  EIGENPY_UNUSED_TYPE(Vector1s);
+  EIGENPY_UNUSED_TYPE(RowVector1s);
+  ENABLE_SPECIFIC_MATRIX_TYPE(Matrix1s);
+
   ENABLE_SPECIFIC_MATRIX_TYPE(Vector2s);
   ENABLE_SPECIFIC_MATRIX_TYPE(RowVector2s);
   ENABLE_SPECIFIC_MATRIX_TYPE(Matrix2s);
@@ -56,11 +57,19 @@ EIGEN_DONT_INLINE void exposeType() {
   ENABLE_SPECIFIC_MATRIX_TYPE(VectorXs);
   ENABLE_SPECIFIC_MATRIX_TYPE(RowVectorXs);
   ENABLE_SPECIFIC_MATRIX_TYPE(MatrixXs);
+
+  enableEigenPySpecific<SparseMatrixXs>();
 }
 
 template <typename Scalar>
 EIGEN_DONT_INLINE void exposeType() {
   exposeType<Scalar, 0>();
+
+#ifdef EIGENPY_WITH_TENSOR_SUPPORT
+  enableEigenPySpecific<Eigen::Tensor<Scalar, 1> >();
+  enableEigenPySpecific<Eigen::Tensor<Scalar, 2> >();
+  enableEigenPySpecific<Eigen::Tensor<Scalar, 3> >();
+#endif
 }
 
 }  // namespace eigenpy