src/numpy.cpp

 /*
- * Copyright 2020-2021 INRIA
+ * Copyright 2020-2024 INRIA
  */
 
 #include "eigenpy/numpy.hpp"
 
-namespace eigenpy
-{
-  void import_numpy()
-  {
-    if(_import_array() < 0)
-    {
-      PyErr_Print();
-      PyErr_SetString(PyExc_ImportError, "numpy.core.multiarray failed to import");
-    }
+namespace eigenpy {
+void import_numpy() {
+  if (_import_array() < 0) {
+    PyErr_Print();
+    PyErr_SetString(PyExc_ImportError,
+                    "numpy.core.multiarray failed to import");
   }
+}
 
-  int PyArray_TypeNum(PyTypeObject * type)
-  {
-    return PyArray_TypeNumFromName(const_cast<char*>(type->tp_name));
+int PyArray_TypeNum(PyTypeObject* type) {
+  PyArray_Descr* descr =
+      PyArray_DescrFromTypeObject(reinterpret_cast<PyObject*>(type));
+  if (descr == NULL) {
+    return NPY_NOTYPE;
   }
+  return descr->type_num;
+}
 
 #if defined _WIN32 || defined __CYGWIN__
 
-  bool call_PyArray_Check(PyObject * py_obj)
-  {
-    return PyArray_Check(py_obj);
-  }
+bool call_PyArray_Check(PyObject* py_obj) { return PyArray_Check(py_obj); }
 
-  PyObject* call_PyArray_SimpleNew(int nd, npy_intp * shape, int np_type)
-  {
-    return PyArray_SimpleNew(nd,shape,np_type);
-  }
+PyObject* call_PyArray_SimpleNew(int nd, npy_intp* shape, int np_type) {
+  return PyArray_SimpleNew(nd, shape, np_type);
+}
 
-  PyObject* call_PyArray_New(PyTypeObject * py_type_ptr, int nd, npy_intp * shape, int np_type, void * data_ptr, int options)
-  {
-    return PyArray_New(py_type_ptr,nd,shape,np_type,NULL,data_ptr,0,options,NULL);
-  }
-  
-  int call_PyArray_ObjectType(PyObject * obj, int val)
-  {
-    return PyArray_ObjectType(obj,val);
-  }
+PyObject* call_PyArray_New(PyTypeObject* py_type_ptr, int nd, npy_intp* shape,
+                           int np_type, void* data_ptr, int options) {
+  return PyArray_New(py_type_ptr, nd, shape, np_type, NULL, data_ptr, 0,
+                     options, NULL);
+}
 
-  PyTypeObject * getPyArrayType() { return &PyArray_Type; }
+PyObject* call_PyArray_New(PyTypeObject* py_type_ptr, int nd, npy_intp* shape,
+                           int np_type, npy_intp* strides, void* data_ptr,
+                           int options) {
+  return PyArray_New(py_type_ptr, nd, shape, np_type, strides, data_ptr, 0,
+                     options, NULL);
+}
 
-  PyArray_Descr * call_PyArray_DescrFromType(int typenum)
-  {
-    return PyArray_DescrFromType(typenum);
-  }
+int call_PyArray_ObjectType(PyObject* obj, int val) {
+  return PyArray_ObjectType(obj, val);
+}
 
-  void call_PyArray_InitArrFuncs(PyArray_ArrFuncs * funcs)
-  {
-    PyArray_InitArrFuncs(funcs);
-  }
+PyTypeObject* getPyArrayType() { return &PyArray_Type; }
 
-  int call_PyArray_RegisterDataType(PyArray_Descr * dtype)
-  {
-    return PyArray_RegisterDataType(dtype);
-  }
+PyArray_Descr* call_PyArray_DescrFromType(int typenum) {
+  return PyArray_DescrFromType(typenum);
+}
 
-  PyArray_Descr * call_PyArray_MinScalarType(PyArrayObject * arr)
-  {
-    return PyArray_MinScalarType(arr);
-  }
+void call_PyArray_InitArrFuncs(PyArray_ArrFuncs* funcs) {
+  PyArray_InitArrFuncs(funcs);
+}
 
-  int call_PyArray_RegisterCanCast(PyArray_Descr *descr, int totype, NPY_SCALARKIND scalar)
-  {
-    return PyArray_RegisterCanCast(descr,totype,scalar);
-  }
+int call_PyArray_RegisterDataType(PyArray_DescrProto* dtype) {
+  return PyArray_RegisterDataType(dtype);
+}
 
-  int call_PyArray_RegisterCastFunc(PyArray_Descr* descr, int totype, PyArray_VectorUnaryFunc* castfunc)
-  {
-    return PyArray_RegisterCastFunc(descr,totype,castfunc);
-  }
+PyArray_Descr* call_PyArray_MinScalarType(PyArrayObject* arr) {
+  return PyArray_MinScalarType(arr);
+}
 
-#endif
+int call_PyArray_RegisterCanCast(PyArray_Descr* descr, int totype,
+                                 NPY_SCALARKIND scalar) {
+  return PyArray_RegisterCanCast(descr, totype, scalar);
+}
+
+int call_PyArray_RegisterCastFunc(PyArray_Descr* descr, int totype,
+                                  PyArray_VectorUnaryFunc* castfunc) {
+  return PyArray_RegisterCastFunc(descr, totype, castfunc);
 }
+
+#endif
+}  // namespace eigenpy

src/optional.cpp

+///
+/// Copyright 2023 CNRS, INRIA
+///
+
+#include "eigenpy/optional.hpp"
+
+namespace eigenpy {
+void exposeNoneType() {
+  detail::NoneToPython<boost::none_t>::registration();
+#ifdef EIGENPY_WITH_CXX17_SUPPORT
+  detail::NoneToPython<std::nullopt_t>::registration();
+#endif
+}
+}  // namespace eigenpy

src/quaternion.cpp

 /*
  * Copyright 2014-2019, CNRS
- * Copyright 2018-2019, INRIA
+ * Copyright 2018-2023, INRIA
  */
 
-#include "eigenpy/memory.hpp"
+#include <Eigen/Geometry>
+
 #include "eigenpy/geometry.hpp"
 #include "eigenpy/quaternion.hpp"
 
-EIGENPY_DEFINE_STRUCT_ALLOCATOR_SPECIALIZATION(Eigen::Quaterniond)
-
-namespace eigenpy
-{
-  void exposeQuaternion()
-  {
-    expose<Eigen::Quaterniond>();
-  }
-} // namespace eigenpy
+namespace eigenpy {
+void exposeQuaternion() { expose<Eigen::Quaterniond>(); }
+}  // namespace eigenpy

src/register.cpp

@@ -4,111 +4,116 @@
 
 #include "eigenpy/register.hpp"
 
-namespace eigenpy
-{
+namespace eigenpy {
 
-  PyArray_Descr * Register::getPyArrayDescr(PyTypeObject * py_type_ptr)
-  {
-    MapDescr::iterator it = instance().py_array_descr_bindings.find(py_type_ptr);
-    if(it != instance().py_array_descr_bindings.end())
-      return it->second;
-    else
-      return NULL;
-  }
-  
-  bool Register::isRegistered(PyTypeObject * py_type_ptr)
-  {
-    if(getPyArrayDescr(py_type_ptr) != NULL)
-      return true;
-    else
-      return false;
-  }
-  
-  int Register::getTypeCode(PyTypeObject * py_type_ptr)
-  {
-    MapCode::iterator it = instance().py_array_code_bindings.find(py_type_ptr);
-    if(it != instance().py_array_code_bindings.end())
-      return it->second;
-    else
-      return PyArray_TypeNum(py_type_ptr);
-  }
+PyArray_Descr* Register::getPyArrayDescr(PyTypeObject* py_type_ptr) {
+  MapDescr::iterator it = instance().py_array_descr_bindings.find(py_type_ptr);
+  if (it != instance().py_array_descr_bindings.end())
+    return it->second;
+  else
+    return NULL;
+}
 
-  int Register::registerNewType(PyTypeObject * py_type_ptr,
-                                const std::type_info * type_info_ptr,
-                                const int type_size,
-                                const int alignement,
-                                PyArray_GetItemFunc * getitem,
-                                PyArray_SetItemFunc * setitem,
-                                PyArray_NonzeroFunc * nonzero,
-                                PyArray_CopySwapFunc * copyswap,
-                                PyArray_CopySwapNFunc * copyswapn,
-                                PyArray_DotFunc * dotfunc,
-                                PyArray_FillFunc * fill,
-                                PyArray_FillWithScalarFunc * fillwithscalar)
-  {
-    namespace bp = boost::python;
-
-    bp::tuple tp_bases_extended(bp::make_tuple(bp::handle<>(bp::borrowed(&PyGenericArrType_Type))));
-    tp_bases_extended += bp::tuple(bp::handle<>(bp::borrowed(py_type_ptr->tp_bases)));
-                                
-    Py_INCREF(tp_bases_extended.ptr());
-    py_type_ptr->tp_bases = tp_bases_extended.ptr();
-
-    py_type_ptr->tp_flags &= ~Py_TPFLAGS_READY; // to force the rebuild
-//    py_type_ptr->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HEAPTYPE;
-    if(PyType_Ready(py_type_ptr) < 0) // Force rebuilding of the __bases__ and mro
-    {
-      throw std::invalid_argument("PyType_Ready fails to initialize input type.");
+PyArray_Descr* Register::getPyArrayDescrFromTypeNum(const int type_num) {
+  if (type_num >= NPY_USERDEF) {
+    for (const auto& elt : instance().py_array_code_bindings) {
+      if (elt.second == type_num)
+        return instance().py_array_descr_bindings[elt.first];
     }
+    return nullptr;
+  } else
+    return PyArray_DescrFromType(type_num);
+}
 
-    PyArray_Descr * descr_ptr = new PyArray_Descr(*call_PyArray_DescrFromType(NPY_OBJECT));
-    PyArray_Descr & descr = *descr_ptr;
-    descr.typeobj = py_type_ptr;
-    descr.kind = 'V';
-    descr.byteorder = '=';
-    descr.type = 'r';
-    descr.elsize = type_size;
-    descr.flags = NPY_NEEDS_PYAPI | NPY_USE_GETITEM | NPY_USE_SETITEM | NPY_NEEDS_INIT;
-    descr.type_num = 0;
-    descr.names = 0;
-    descr.fields = 0;
-    descr.alignment = alignement; //call_PyArray_DescrFromType(NPY_OBJECT)->alignment;
-    
-    PyArray_ArrFuncs * funcs_ptr = new PyArray_ArrFuncs;
-    PyArray_ArrFuncs & funcs = *funcs_ptr;
-    descr.f = funcs_ptr;
-    call_PyArray_InitArrFuncs(funcs_ptr);
-    funcs.getitem = getitem;
-    funcs.setitem = setitem;
-    funcs.nonzero = nonzero;
-    funcs.copyswap = copyswap;
-    funcs.copyswapn = copyswapn;
-    funcs.dotfunc = dotfunc;
-    funcs.fill = fill;
-    funcs.fillwithscalar = fillwithscalar;
-    //      f->cast = cast;
-    
-    const int code = call_PyArray_RegisterDataType(descr_ptr);
-    assert(code >= 0 && "The return code should be positive");
-    PyArray_Descr * new_descr = call_PyArray_DescrFromType(code);
-
-    if(PyDict_SetItemString(py_type_ptr->tp_dict,"dtype",(PyObject*)descr_ptr) < 0)
-    {
-      throw std::invalid_argument("PyDict_SetItemString fails.");
-    }
-    
-    instance().type_to_py_type_bindings.insert(std::make_pair(type_info_ptr,py_type_ptr));
-    instance().py_array_descr_bindings[py_type_ptr] = new_descr;
-    instance().py_array_code_bindings[py_type_ptr] = code;
-    
-    //      PyArray_RegisterCanCast(descr,NPY_OBJECT,NPY_NOSCALAR);
-    return code;
-  }
+bool Register::isRegistered(PyTypeObject* py_type_ptr) {
+  if (getPyArrayDescr(py_type_ptr) != NULL)
+    return true;
+  else
+    return false;
+}
+
+int Register::getTypeCode(PyTypeObject* py_type_ptr) {
+  MapCode::iterator it = instance().py_array_code_bindings.find(py_type_ptr);
+  if (it != instance().py_array_code_bindings.end())
+    return it->second;
+  else
+    return PyArray_TypeNum(py_type_ptr);
+}
 
-  Register & Register::instance()
+int Register::registerNewType(
+    PyTypeObject* py_type_ptr, const std::type_info* type_info_ptr,
+    const int type_size, const int alignement, PyArray_GetItemFunc* getitem,
+    PyArray_SetItemFunc* setitem, PyArray_NonzeroFunc* nonzero,
+    PyArray_CopySwapFunc* copyswap, PyArray_CopySwapNFunc* copyswapn,
+    PyArray_DotFunc* dotfunc, PyArray_FillFunc* fill,
+    PyArray_FillWithScalarFunc* fillwithscalar) {
+  bp::tuple tp_bases_extended(
+      bp::make_tuple(bp::handle<>(bp::borrowed(&PyGenericArrType_Type))));
+  tp_bases_extended +=
+      bp::tuple(bp::handle<>(bp::borrowed(py_type_ptr->tp_bases)));
+
+  Py_INCREF(tp_bases_extended.ptr());
+  py_type_ptr->tp_bases = tp_bases_extended.ptr();
+
+  py_type_ptr->tp_flags &= ~Py_TPFLAGS_READY;  // to force the rebuild
+  //    py_type_ptr->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HEAPTYPE;
+  if (PyType_Ready(py_type_ptr) <
+      0)  // Force rebuilding of the __bases__ and mro
   {
-    static Register self;
-    return self;
+    throw std::invalid_argument("PyType_Ready fails to initialize input type.");
+  }
+
+  PyArray_DescrProto* descr_ptr = new PyArray_DescrProto();
+  PyArray_DescrProto& descr = *descr_ptr;
+  descr.typeobj = py_type_ptr;
+  descr.kind = 'V';
+  descr.byteorder = '=';
+  descr.type = 'r';
+  descr.elsize = type_size;
+  descr.flags =
+      NPY_NEEDS_PYAPI | NPY_USE_GETITEM | NPY_USE_SETITEM | NPY_NEEDS_INIT;
+  descr.type_num = 0;
+  descr.names = 0;
+  descr.fields = 0;
+  descr.alignment =
+      alignement;  // call_PyArray_DescrFromType(NPY_OBJECT)->alignment;
+
+  PyArray_ArrFuncs* funcs_ptr = new PyArray_ArrFuncs;
+  PyArray_ArrFuncs& funcs = *funcs_ptr;
+  descr.f = funcs_ptr;
+  call_PyArray_InitArrFuncs(funcs_ptr);
+  funcs.getitem = getitem;
+  funcs.setitem = setitem;
+  funcs.nonzero = nonzero;
+  funcs.copyswap = copyswap;
+  funcs.copyswapn = copyswapn;
+  funcs.dotfunc = dotfunc;
+  funcs.fill = fill;
+  funcs.fillwithscalar = fillwithscalar;
+  //      f->cast = cast;
+  Py_SET_TYPE(descr_ptr, &PyArrayDescr_Type);
+
+  const int code = call_PyArray_RegisterDataType(descr_ptr);
+  assert(code >= 0 && "The return code should be positive");
+  PyArray_Descr* new_descr = call_PyArray_DescrFromType(code);
+
+  if (PyDict_SetItemString(py_type_ptr->tp_dict, "dtype",
+                           (PyObject*)new_descr) < 0) {
+    throw std::invalid_argument("PyDict_SetItemString fails.");
   }
 
-} // namespace eigenpy
+  instance().type_to_py_type_bindings.insert(
+      std::make_pair(type_info_ptr, py_type_ptr));
+  instance().py_array_descr_bindings[py_type_ptr] = new_descr;
+  instance().py_array_code_bindings[py_type_ptr] = code;
+
+  //      PyArray_RegisterCanCast(descr,NPY_OBJECT,NPY_NOSCALAR);
+  return code;
+}
+
+Register& Register::instance() {
+  static Register self;
+  return self;
+}
+
+}  // namespace eigenpy

src/scipy-type.cpp

+/*
+ * Copyright 2024 INRIA
+ */
+
+#include "eigenpy/scipy-type.hpp"
+
+#include <patchlevel.h>  // For PY_MAJOR_VERSION
+
+namespace eigenpy {
+
+ScipyType& ScipyType::getInstance() {
+  static ScipyType instance;
+  return instance;
+}
+
+void ScipyType::sharedMemory(const bool value) {
+  getInstance().shared_memory = value;
+}
+
+bool ScipyType::sharedMemory() { return getInstance().shared_memory; }
+
+const PyTypeObject* ScipyType::getScipyCSRMatrixType() {
+  return getInstance().csr_matrix_type;
+}
+
+const PyTypeObject* ScipyType::getScipyCSCMatrixType() {
+  return getInstance().csc_matrix_type;
+}
+
+ScipyType::ScipyType() {
+  try {
+    sparse_module = bp::import("scipy.sparse");
+  } catch (...) {
+    throw std::runtime_error(
+        "SciPy is not installed. "
+        "You can install it using the command \'pip install scipy\'.");
+  }
+
+#if PY_MAJOR_VERSION >= 3
+  // TODO I don't know why this Py_INCREF is necessary.
+  // Without it, the destructor of ScipyType SEGV sometimes.
+  Py_INCREF(sparse_module.ptr());
+#endif
+
+  csr_matrix_obj = sparse_module.attr("csr_matrix");
+  csr_matrix_type = reinterpret_cast<PyTypeObject*>(csr_matrix_obj.ptr());
+  csc_matrix_obj = sparse_module.attr("csc_matrix");
+  csc_matrix_type = reinterpret_cast<PyTypeObject*>(csc_matrix_obj.ptr());
+
+  shared_memory = true;
+}
+}  // namespace eigenpy

src/solvers/preconditioners.cpp

 /*
- * Copyright 2017-2018, Justin Carpentier, LAAS-CNRS
- *
- * This file is part of eigenpy.
- * eigenpy is free software: you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public License
- * as published by the Free Software Foundation, either version 3 of
- * the License, or (at your option) any later version.
- * eigenpy is distributed in the hope that it will be
- * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
- * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.  You should
- * have received a copy of the GNU Lesser General Public License along
- * with eigenpy.  If not, see <http://www.gnu.org/licenses/>.
+ * Copyright 2017 CNRS
  */
 
 #include <Eigen/Core>
 
-#if EIGEN_VERSION_AT_LEAST(3,2,0)
-#include "eigenpy/solvers/preconditioners.hpp"
+#if EIGEN_VERSION_AT_LEAST(3, 2, 0)
 #include "eigenpy/solvers/BasicPreconditioners.hpp"
-//#include "eigenpy/solvers/BFGSPreconditioners.hpp"
+#include "eigenpy/solvers/preconditioners.hpp"
+// #include "eigenpy/solvers/BFGSPreconditioners.hpp"
 
-namespace eigenpy
-{
+namespace eigenpy {
 
-  void exposePreconditioners()
-  {
-    using namespace Eigen;
-    
-    DiagonalPreconditionerVisitor<double>::expose();
-#if EIGEN_VERSION_AT_LEAST(3,3,5)
-    LeastSquareDiagonalPreconditionerVisitor<double>::expose();
+void exposePreconditioners() {
+  using namespace Eigen;
+
+  DiagonalPreconditionerVisitor<double>::expose();
+#if EIGEN_VERSION_AT_LEAST(3, 3, 5)
+  LeastSquareDiagonalPreconditionerVisitor<double>::expose();
 #endif
-    IdentityPreconditionerVisitor::expose();
-//      LimitedBFGSPreconditionerBaseVisitor< LimitedBFGSPreconditioner<double,Eigen::Dynamic,Eigen::Upper|Eigen::Lower> >::expose("LimitedBFGSPreconditioner");
-   
-  }
+  IdentityPreconditionerVisitor::expose();
+  //      LimitedBFGSPreconditionerBaseVisitor<
+  //      LimitedBFGSPreconditioner<double,Eigen::Dynamic,Eigen::Upper|Eigen::Lower>
+  //      >::expose("LimitedBFGSPreconditioner");
+}
 
-} // namespace eigenpy
+}  // namespace eigenpy
 
 #endif
-

src/solvers/solvers.cpp

@@ -4,30 +4,34 @@
 
 #include <Eigen/Core>
 
-#if EIGEN_VERSION_AT_LEAST(3,2,0)
+#if EIGEN_VERSION_AT_LEAST(3, 2, 0)
 
-#include "eigenpy/solvers/solvers.hpp"
 #include "eigenpy/solvers/ConjugateGradient.hpp"
+#include "eigenpy/solvers/solvers.hpp"
 
-#if EIGEN_VERSION_AT_LEAST(3,3,5)
-  #include "eigenpy/solvers/LeastSquaresConjugateGradient.hpp"
+#if EIGEN_VERSION_AT_LEAST(3, 3, 5)
+#include "eigenpy/solvers/LeastSquaresConjugateGradient.hpp"
 #endif
 
-namespace eigenpy
-{
-  void exposeSolvers()
-  {
-    using namespace Eigen;
-    ConjugateGradientVisitor< ConjugateGradient<MatrixXd,Lower|Upper> >::expose();
-#if EIGEN_VERSION_AT_LEAST(3,3,5)
-    LeastSquaresConjugateGradientVisitor< LeastSquaresConjugateGradient<MatrixXd, LeastSquareDiagonalPreconditioner<MatrixXd::Scalar> > >::expose();
+namespace eigenpy {
+void exposeSolvers() {
+  using namespace Eigen;
+  ConjugateGradientVisitor<
+      ConjugateGradient<MatrixXd, Lower | Upper> >::expose();
+#if EIGEN_VERSION_AT_LEAST(3, 3, 5)
+  LeastSquaresConjugateGradientVisitor<LeastSquaresConjugateGradient<
+      MatrixXd,
+      LeastSquareDiagonalPreconditioner<MatrixXd::Scalar> > >::expose();
 #endif
-    
-    // Conjugate gradient with limited BFGS preconditioner
-    ConjugateGradientVisitor< ConjugateGradient<MatrixXd,Lower|Upper,IdentityPreconditioner > >::expose("IdentityConjugateGradient");
-//    ConjugateGradientVisitor< ConjugateGradient<MatrixXd,Lower|Upper,LimitedBFGSPreconditioner<double,Dynamic,Lower|Upper> > >::expose("LimitedBFGSConjugateGradient");
-  }
-} // namespace eigenpy
 
-#endif
+  // Conjugate gradient with limited BFGS preconditioner
+  ConjugateGradientVisitor<
+      ConjugateGradient<MatrixXd, Lower | Upper, IdentityPreconditioner> >::
+      expose("IdentityConjugateGradient");
+  //    ConjugateGradientVisitor<
+  //    ConjugateGradient<MatrixXd,Lower|Upper,LimitedBFGSPreconditioner<double,Dynamic,Lower|Upper>
+  //    > >::expose("LimitedBFGSConjugateGradient");
+}
+}  // namespace eigenpy
 
+#endif

src/std-vector.cpp

+/*
+ * Copyright 2022, CNRS
+ * Copyright 2022, INRIA
+ */
+
+#include "eigenpy/std-vector.hpp"
+
+namespace eigenpy {
+
+void exposeStdVector() {
+  exposeStdVectorEigenSpecificType<Eigen::MatrixXd>("MatrixXd");
+  exposeStdVectorEigenSpecificType<Eigen::VectorXd>("VectorXd");
+
+  exposeStdVectorEigenSpecificType<Eigen::MatrixXi>("MatrixXi");
+  exposeStdVectorEigenSpecificType<Eigen::VectorXi>("VectorXi");
+}
+
+}  // namespace eigenpy

src/type_info.cpp

+///
+/// Copyright 2024 INRIA
+///
+
+#include <typeinfo>
+#include <typeindex>
+
+#include <boost/python.hpp>
+#include <boost/type_index.hpp>
+
+#include "eigenpy/registration.hpp"
+
+namespace bp = boost::python;
+
+namespace eigenpy {
+
+void exposeStdTypeIndex() {
+  typedef std::type_index Self;
+  if (register_symbolic_link_to_registered_type<Self>()) return;
+
+  bp::class_<Self>(
+      "std_type_index",
+      "The class type_index holds implementation-specific information about a "
+      "type, including the name of the type and means to compare two types for "
+      "equality or collating order.",
+      bp::no_init)
+      .def(bp::self == bp::self)
+      .def(bp::self >= bp::self)
+      .def(bp::self > bp::self)
+      .def(bp::self < bp::self)
+      .def(bp::self <= bp::self)
+      .def("hash_code", &Self::hash_code, bp::arg("self"),
+           "Returns an unspecified value (here denoted by hash code) such that "
+           "for all std::type_info objects referring to the same type, their "
+           "hash code is the same.")
+      .def("name", &Self::name, bp::arg("self"),
+           "Returns an implementation defined null-terminated character string "
+           "containing the name of the type. No guarantees are given; in "
+           "particular, the returned string can be identical for several types "
+           "and change between invocations of the same program.")
+      .def(
+          "pretty_name",
+          +[](const Self &value) -> std::string {
+            return boost::core::demangle(value.name());
+          },
+          bp::arg("self"), "Human readible name.");
+}
+
+void exposeBoostTypeIndex() {
+  typedef boost::typeindex::type_index Self;
+  if (register_symbolic_link_to_registered_type<Self>()) return;
+
+  bp::class_<Self>(
+      "boost_type_index",
+      "The class type_index holds implementation-specific information about a "
+      "type, including the name of the type and means to compare two types for "
+      "equality or collating order.",
+      bp::no_init)
+      .def(bp::self == bp::self)
+      .def(bp::self >= bp::self)
+      .def(bp::self > bp::self)
+      .def(bp::self < bp::self)
+      .def(bp::self <= bp::self)
+      .def("hash_code", &Self::hash_code, bp::arg("self"),
+           "Returns an unspecified value (here denoted by hash code) such that "
+           "for all std::type_info objects referring to the same type, their "
+           "hash code is the same.")
+      .def("name", &Self::name, bp::arg("self"),
+           "Returns an implementation defined null-terminated character string "
+           "containing the name of the type. No guarantees are given; in "
+           "particular, the returned string can be identical for several types "
+           "and change between invocations of the same program.")
+      .def("pretty_name", &Self::pretty_name, bp::arg("self"),
+           "Human readible name.");
+}
+
+void exposeTypeInfo() {
+  exposeStdTypeIndex();
+  exposeBoostTypeIndex();
+}
+}  // namespace eigenpy

src/version.cpp

 //
-// Copyright (c) 2019 INRIA
+// Copyright (c) 2019-2023 INRIA
 //
 
-#include "eigenpy/config.hpp"
 #include "eigenpy/version.hpp"
+#include "eigenpy/config.hpp"
 
 #include <sstream>
+#include <Eigen/Core>
 
-namespace eigenpy
-{
+namespace eigenpy {
 
-  std::string printVersion(const std::string & delimiter)
-  {
-    std::ostringstream oss;
-    oss
-    << EIGENPY_MAJOR_VERSION << delimiter
-    << EIGENPY_MINOR_VERSION << delimiter
-    << EIGENPY_PATCH_VERSION;
-    return oss.str();
-  }
+std::string printVersion(const std::string& delimiter) {
+  std::ostringstream oss;
+  oss << EIGENPY_MAJOR_VERSION << delimiter << EIGENPY_MINOR_VERSION
+      << delimiter << EIGENPY_PATCH_VERSION;
+  return oss.str();
+}
 
-  bool checkVersionAtLeast(unsigned int major_version,
-                           unsigned int minor_version,
-                           unsigned int patch_version)
-  {
-    return EIGENPY_VERSION_AT_LEAST(major_version,minor_version,patch_version);
-  }
+std::string printEigenVersion(const std::string& delimiter) {
+  std::ostringstream oss;
+  oss << EIGEN_MAJOR_VERSION << delimiter << EIGEN_MINOR_VERSION << delimiter
+      << EIGEN_MINOR_VERSION;
+  return oss.str();
+}
 
+bool checkVersionAtLeast(unsigned int major_version, unsigned int minor_version,
+                         unsigned int patch_version) {
+  return EIGENPY_VERSION_AT_LEAST(major_version, minor_version, patch_version);
 }
+
+}  // namespace eigenpy

travis_custom/custom_before_install

-#!/bin/bash
-
-# Add Python dependency
-echo "TRAVIS_PYTHON_VERSION=$TRAVIS_PYTHON_VERSION"
-if [[ $TRAVIS_PYTHON_VERSION -gt 30 ]]; then
-  export APT_DEPENDENCIES=$APT_DEPENDENCIES" python3-numpy"
-fi
-
-# When this script is called the current directory is ./custom_travis
-. ./.travis/run ../.travis/before_install
-
-# Git fetch tags
-git fetch --tags
-

travis_custom/custom_build

-#!/bin/bash
-set -e
-
-# Setup environment variables.
-export CMAKE_ADDITIONAL_OPTIONS=" ${CMAKE_ADDITIONAL_OPTIONS} -DBUILD_BENCHMARK=\"ON\" -DBUILD_TESTING=\"ON\" -DCMAKE_CXX_FLAGS=-DBOOST_SYSTEM_NO_DEPRECATED"
-if [[ ";${DO_INSTALL_DOC_EXCEPT_ON_BRANCH};" == *";${CI_BRANCH};"* ]]; then
-  export CMAKE_ADDITIONAL_OPTIONS=" ${CMAKE_ADDITIONAL_OPTIONS} -DINSTALL_DOCUMENTATION=\"OFF\""
-else
-  export CMAKE_ADDITIONAL_OPTIONS=" ${CMAKE_ADDITIONAL_OPTIONS} -DINSTALL_DOCUMENTATION=\"ON\""
-fi
-
-if [[ $TRAVIS_PYTHON_VERSION -gt 30 ]]; then
-  export CMAKE_ADDITIONAL_OPTIONS=" ${CMAKE_ADDITIONAL_OPTIONS} -DPYTHON_EXECUTABLE=$(which python3)"
-fi
-
-# Setup environment variables.
-. ./.travis/run ../.travis/build
-

unittest/CMakeLists.txt

 #
-# Copyright (c) 2014-2019 CNRS
-# Copyright (c) 2018-2021 INRIA
+# Copyright (c) 2014-2019 CNRS Copyright (c) 2018-2024 INRIA
 #
 
-MACRO(ADD_LIB_UNIT_TEST test)
-  CREATE_CTEST_BUILD_TESTS_TARGET()
+function(ADD_LIB_UNIT_TEST test)
+  create_ctest_build_tests_target()
+  set(test_target ${PROJECT_NAME}-${test})
+
+  if(BUILD_TESTING)
+    add_library(${test_target} SHARED "${test}.cpp")
+  else()
+    add_library(${test_target} SHARED EXCLUDE_FROM_ALL "${test}.cpp")
+  endif()
+  set_standard_output_directory(${test_target})
+
+  target_link_libraries(${test_target} PUBLIC ${PROJECT_NAME})
+  set_target_properties(
+    ${test_target}
+    PROPERTIES PREFIX ""
+               LIBRARY_OUTPUT_NAME ${test}
+               RUNTIME_OUTPUT_NAME ${test})
+
+  set_target_properties(${test_target} PROPERTIES SUFFIX ${PYTHON_EXT_SUFFIX})
+
+  add_test(
+    NAME ${test_target}
+    COMMAND ${PYTHON_EXECUTABLE} -c "import ${test}"
+    WORKING_DIRECTORY $<TARGET_FILE_DIR:${test_target}>)
+
+  add_dependencies(build_tests ${test_target})
+  if(NOT BUILD_TESTING)
+    set_tests_properties(${test_target} PROPERTIES DEPENDS ctest_build_tests)
+  endif(NOT BUILD_TESTING)
+endfunction()
+
+add_dependencies(build_tests ${PYWRAP})
+add_lib_unit_test(matrix)
+add_lib_unit_test(type_info)
+add_lib_unit_test(multiple_registration)
+if(BUILD_TESTING_SCIPY)
+  find_scipy()
+  add_lib_unit_test(sparse_matrix)
+endif()
+add_lib_unit_test(tensor)
+add_lib_unit_test(geometry)
+add_lib_unit_test(complex)
+add_lib_unit_test(deprecation_policy)
+add_lib_unit_test(return_by_ref)
+add_lib_unit_test(include)
+if(NOT ${EIGEN3_VERSION} VERSION_LESS "3.2.0")
+  add_lib_unit_test(eigen_ref)
+endif()
+
+if(NOT NUMPY_WITH_BROKEN_UFUNC_SUPPORT)
+  add_lib_unit_test(user_type)
+endif()
+add_lib_unit_test(std_vector)
+add_lib_unit_test(std_array)
+add_lib_unit_test(std_pair)
+add_lib_unit_test(std_map)
+add_lib_unit_test(user_struct)
+
+if(CMAKE_CXX_STANDARD GREATER 14 AND CMAKE_CXX_STANDARD LESS 98)
+  add_lib_unit_test(std_unique_ptr)
+endif()
+
+function(add_python_lib_unit_test name source)
+  set(test_target ${PROJECT_NAME}-${name})
+  add_python_unit_test(${test_target} ${source} "lib" "bin")
+endfunction()
+
+function(add_python_eigenpy_lib_unit_test name source)
+  set(test_target ${PROJECT_NAME}-${name})
+  add_python_unit_test(${test_target} ${source} "lib" "bin" "python")
+  set_tests_properties(${test_target} PROPERTIES DEPENDS ${PYWRAP})
+endfunction()
+
+function(add_python_eigenpy_unit_test name source)
+  set(test_target ${PROJECT_NAME}-${name})
+  add_python_unit_test(${test_target} ${source} "python")
+  set_tests_properties(${test_target} PROPERTIES DEPENDS ${PYWRAP})
+endfunction()
+
+function(config_test test tagname opttype)
+  set(MODNAME ${test}_${tagname})
+  set(TEST_TYPE ${opttype})
+  configure_file(${test}.cpp.in ${CMAKE_CURRENT_BINARY_DIR}/${MODNAME}.cpp)
+
+  set(py_file test_${test}_${tagname}.py)
+  configure_file(python/test_${test}.py.in
+                 ${CMAKE_CURRENT_BINARY_DIR}/python/${py_file})
+  add_lib_unit_test(${MODNAME})
+  set(PYTHON_TEST_NAME "${PROJECT_NAME}-py-${test}-${tagname}")
+  add_test(NAME ${PYTHON_TEST_NAME}
+           COMMAND ${PYTHON_EXECUTABLE}
+                   "${CMAKE_CURRENT_BINARY_DIR}/python/${py_file}")
+  compute_pythonpath(ENV_VARIABLES "lib" "bin")
+  set_tests_properties(${PYTHON_TEST_NAME} PROPERTIES ENVIRONMENT
+                                                      "${ENV_VARIABLES}")
+endfunction()
+
+config_test(variant boost "boost::variant")
+if(CMAKE_CXX_STANDARD GREATER 14 AND CMAKE_CXX_STANDARD LESS 98)
+  config_test(variant std "std::variant")
+endif()
+
+config_test(bind_optional boost "boost::optional")
+if(CMAKE_CXX_STANDARD GREATER 14 AND CMAKE_CXX_STANDARD LESS 98)
+  config_test(bind_optional std "std::optional")
+endif()
+
+add_lib_unit_test(bind_virtual_factory)
+
+add_python_lib_unit_test("py-matrix" "unittest/python/test_matrix.py")
+add_python_lib_unit_test("py-type-info" "unittest/python/test_type_info.py")
+add_python_lib_unit_test("py-multiple-registration"
+                         "unittest/python/test_multiple_registration.py")
+
+add_python_lib_unit_test("py-tensor" "unittest/python/test_tensor.py")
+add_python_lib_unit_test("py-geometry" "unittest/python/test_geometry.py")
+add_python_lib_unit_test("py-complex" "unittest/python/test_complex.py")
+add_python_lib_unit_test("py-deprecation-policy"
+                         "unittest/python/test_deprecation_policy.py")
+add_python_lib_unit_test("py-return-by-ref"
+                         "unittest/python/test_return_by_ref.py")
+add_python_lib_unit_test("py-eigen-ref" "unittest/python/test_eigen_ref.py")
+
+if(NOT NUMPY_WITH_BROKEN_UFUNC_SUPPORT)
+  add_python_lib_unit_test("py-user-type" "unittest/python/test_user_type.py")
+endif()
+
+add_python_eigenpy_lib_unit_test("py-dimensions"
+                                 "unittest/python/test_dimensions.py")
+
+add_python_eigenpy_lib_unit_test("py-version" "unittest/python/test_version.py")
+
+add_python_eigenpy_lib_unit_test("py-eigen-solver"
+                                 "unittest/python/test_eigen_solver.py")
+
+add_python_eigenpy_lib_unit_test(
+  "py-self-adjoint-eigen-solver"
+  "unittest/python/test_self_adjoint_eigen_solver.py")
+
+add_python_eigenpy_lib_unit_test("py-LLT" "unittest/python/test_LLT.py")
+
+add_python_eigenpy_lib_unit_test("py-LDLT" "unittest/python/test_LDLT.py")
+
+add_python_eigenpy_lib_unit_test("py-id" "unittest/python/test_id.py")
+
+add_python_eigenpy_lib_unit_test("py-QR" "unittest/python/test_QR.py")
+
+if(NOT WIN32)
+  add_python_eigenpy_lib_unit_test("py-MINRES" "unittest/python/test_MINRES.py")
+endif(NOT WIN32)
+
+add_python_eigenpy_lib_unit_test("py-std-vector"
+                                 "unittest/python/test_std_vector.py")
+
+add_python_lib_unit_test("py-std-array" "unittest/python/test_std_array.py")
+
+add_python_lib_unit_test("py-std-map" "unittest/python/test_std_map.py")
+
+add_python_lib_unit_test("py-std-pair" "unittest/python/test_std_pair.py")
+
+add_python_lib_unit_test("py-user-struct" "unittest/python/test_user_struct.py")
+
+if(CMAKE_CXX_STANDARD GREATER 14 AND CMAKE_CXX_STANDARD LESS 98)
+  add_python_lib_unit_test("py-std-unique-ptr"
+                           "unittest/python/test_std_unique_ptr.py")
+endif()
+
+add_python_lib_unit_test("py-bind-virtual"
+                         "unittest/python/test_bind_virtual.py")
+
+if(BUILD_TESTING_SCIPY)
+  add_python_lib_unit_test("py-sparse-matrix"
+                           "unittest/python/test_sparse_matrix.py")
+
+  add_python_eigenpy_unit_test(
+    "py-SimplicialLLT"
+    "unittest/python/decompositions/sparse/test_SimplicialLLT.py")
+  add_python_eigenpy_unit_test(
+    "py-SimplicialLDLT"
+    "unittest/python/decompositions/sparse/test_SimplicialLDLT.py")
+
+  if(BUILD_WITH_CHOLMOD_SUPPORT)
+    add_python_eigenpy_unit_test(
+      "py-CholmodSimplicialLLT"
+      "unittest/python/decompositions/sparse/cholmod/test_CholmodSimplicialLLT.py"
+    )
+
+    add_python_eigenpy_unit_test(
+      "py-CholmodSimplicialLDLT"
+      "unittest/python/decompositions/sparse/cholmod/test_CholmodSimplicialLDLT.py"
+    )
 
-  IF(BUILD_TESTING)
-    ADD_LIBRARY(${test} SHARED "${test}.cpp")
-  ELSE(BUILD_TESTING)
-    ADD_LIBRARY(${test} SHARED EXCLUDE_FROM_ALL "${test}.cpp")
-  ENDIF(BUILD_TESTING)
+    add_python_eigenpy_unit_test(
+      "py-CholmodSupernodalLLT"
+      "unittest/python/decompositions/sparse/cholmod/test_CholmodSupernodalLLT.py"
+    )
+  endif(BUILD_WITH_CHOLMOD_SUPPORT)
 
-  TARGET_LINK_LIBRARIES(${test} PUBLIC ${PROJECT_NAME})
-  SET_TARGET_PROPERTIES(${test} PROPERTIES PREFIX "")
-
-  SET_TARGET_PROPERTIES(${test} PROPERTIES SUFFIX ${PYTHON_EXT_SUFFIX})
-
-  ADD_TEST(NAME ${test} COMMAND ${PYTHON_EXECUTABLE} -c "import ${test}")
-
-  ADD_DEPENDENCIES(build_tests ${test})
-  IF(NOT BUILD_TESTING)
-    SET_TESTS_PROPERTIES(${test} PROPERTIES DEPENDS ctest_build_tests)
-  ENDIF(NOT BUILD_TESTING)
-ENDMACRO(ADD_LIB_UNIT_TEST)
-
-ADD_LIB_UNIT_TEST(matrix)
-ADD_LIB_UNIT_TEST(geometry)
-ADD_LIB_UNIT_TEST(complex)
-ADD_LIB_UNIT_TEST(return_by_ref)
-ADD_LIB_UNIT_TEST(include)
-IF(NOT ${EIGEN3_VERSION} VERSION_LESS "3.2.0")
-  ADD_LIB_UNIT_TEST(eigen_ref)
-ENDIF()
-ADD_LIB_UNIT_TEST(user_type)
-
-ADD_PYTHON_UNIT_TEST("py-matrix" "unittest/python/test_matrix.py" "unittest")
-ADD_PYTHON_UNIT_TEST("py-geometry" "unittest/python/test_geometry.py" "unittest")
-ADD_PYTHON_UNIT_TEST("py-complex" "unittest/python/test_complex.py" "unittest")
-ADD_PYTHON_UNIT_TEST("py-return-by-ref" "unittest/python/test_return_by_ref.py" "unittest")
-ADD_PYTHON_UNIT_TEST("py-eigen-ref" "unittest/python/test_eigen_ref.py" "unittest")
-ADD_PYTHON_UNIT_TEST("py-user-type" "unittest/python/test_user_type.py" "unittest")
-
-ADD_PYTHON_UNIT_TEST("py-switch" "unittest/python/test_switch.py" "python/eigenpy;unittest")
-SET_TESTS_PROPERTIES("py-switch" PROPERTIES DEPENDS ${PYWRAP})
-
-ADD_PYTHON_UNIT_TEST("py-dimensions" "unittest/python/test_dimensions.py" "python/eigenpy;unittest")
-SET_TESTS_PROPERTIES("py-dimensions" PROPERTIES DEPENDS ${PYWRAP})
-
-ADD_PYTHON_UNIT_TEST("py-version" "unittest/python/test_version.py" "python/eigenpy;unittest")
-SET_TESTS_PROPERTIES("py-version" PROPERTIES DEPENDS ${PYWRAP})
-
-ADD_PYTHON_UNIT_TEST("py-eigen-solver" "unittest/python/test_eigen_solver.py" "python/eigenpy;unittest")
-SET_TESTS_PROPERTIES("py-eigen-solver" PROPERTIES DEPENDS ${PYWRAP})
-
-ADD_PYTHON_UNIT_TEST("py-self-adjoint-eigen-solver" "unittest/python/test_self_adjoint_eigen_solver.py" "python/eigenpy;unittest")
-SET_TESTS_PROPERTIES("py-self-adjoint-eigen-solver" PROPERTIES DEPENDS ${PYWRAP})
-
-ADD_PYTHON_UNIT_TEST("py-LLT" "unittest/python/test_LLT.py" "python/eigenpy;unittest")
-SET_TESTS_PROPERTIES("py-LLT" PROPERTIES DEPENDS ${PYWRAP})
-
-ADD_PYTHON_UNIT_TEST("py-LDLT" "unittest/python/test_LDLT.py" "python/eigenpy;unittest")
-SET_TESTS_PROPERTIES("py-LDLT" PROPERTIES DEPENDS ${PYWRAP})
-
-ADD_PYTHON_UNIT_TEST("py-MINRES" "unittest/python/test_MINRES.py" "python/eigenpy;unittest")
-SET_TESTS_PROPERTIES("py-MINRES" PROPERTIES DEPENDS ${PYWRAP})
+  if(BUILD_WITH_ACCELERATE_SUPPORT)
+    add_python_eigenpy_unit_test(
+      "py-Accelerate"
+      "unittest/python/decompositions/sparse/test_Accelerate.py")
+  endif(BUILD_WITH_ACCELERATE_SUPPORT)
+endif()

unittest/alpha/bnpy.cpp

-/* Simple test using the boost::numpy interface: return an array and a matrix. */
-
-#include "eigenpy/fwd.hpp"
-#include "boost/numpy.hpp"
-
-namespace bp = boost::python;
-namespace bn = boost::numpy;
-
-/* Return an dim-1 array with 5 elements. */
-bn::ndarray array() {
-  std::vector<double> v(5);
-  v[0] = 56;
-  Py_intptr_t shape[1] = { v.size() };
-  bn::ndarray result = bn::zeros(1, shape, bn::dtype::get_builtin<double>());
-  std::copy(v.begin(), v.end(), reinterpret_cast<double*>(result.get_data()));
-  return result;
-}
-
-/* Return a dim-1 matrix with five elements. */
-boost::python::object matrix() {
-  std::vector<double> v(5);
-  v[0] = 56;
-  Py_intptr_t shape[1] = { v.size() };
-  bn::matrix t(bn::zeros(1, shape, bn::dtype::get_builtin<double>()));
-  std::copy(v.begin(), v.end(), reinterpret_cast<double*>(t.get_data()));
-
-  return t;
-}
-
-BOOST_PYTHON_MODULE(libbnpy) {
-    bn::initialize();
-    bp::def("array", array);
-    bp::def("matrix", matrix);
-}

unittest/alpha/eigen.cpp

-#include "eigenpy/fwd.hpp"
-#include <boost/numpy.hpp>
-
-
-namespace boopy
-{
-  namespace bpn = boost::numpy;
-  namespace bp = boost::python;
-	
-  struct Eigenvec_to_python_matrix
-  {
-    static PyObject* convert(Eigen::VectorXd const& v)
-    {
-      Py_intptr_t shape[1] = { v.size() };
-      bpn::matrix result(bpn::zeros(1, shape, bpn::dtype::get_builtin<double>()));
-      std::copy(v.data(), v.data()+v.size(), reinterpret_cast<double*>(result.get_data()));
-      return bp::incref(result.ptr());
-    }
-  };
-  
-  struct Eigenvec_from_python_array
-  {
-    Eigenvec_from_python_array()
-    {
-      bp::converter::registry
-	::push_back(&convertible,
-		    &construct,
-		    bp::type_id<Eigen::VectorXd>());
-    }
- 
-    // Determine if obj_ptr can be converted in a Eigenvec
-    static void* convertible(PyObject* obj_ptr)
-    {
-
-      try {
-	bp::object obj(bp::handle<>(bp::borrowed(obj_ptr)));
-	std::auto_ptr<bpn::ndarray> 
-	  array(new bpn::ndarray(bpn::from_object(obj,
-						  bpn::dtype::get_builtin<double>(),
-						  bpn::ndarray::V_CONTIGUOUS)));
-
-	if( (array->get_nd()==1)
-	    || ( (array->get_nd()==2) && (array->get_shape()[1]==1) ))
-	  return array.release();
-	else
-	  return 0;
-      } catch (bp::error_already_set & err) {
-	bp::handle_exception();
-	return 0;
-      }
-    }
- 
-    // Convert obj_ptr into a Eigenvec
-    static void construct(PyObject* ,
-			  bp::converter::rvalue_from_python_stage1_data* memory)
-    {
-      // Recover the pointer created in <convertible>
-      std::auto_ptr<bpn::ndarray> 
-	array(reinterpret_cast<bpn::ndarray*>(memory->convertible));
-      const int nrow = array->get_shape()[0];
-      std::cout << "nrow = " << nrow << std::endl;
-
-      // Get the memory where to create the vector
-      void* storage
-	= ((bp::converter::rvalue_from_python_storage<Eigen::VectorXd>*)memory)
-	->storage.bytes;
-
-      // Create the vector
-      Eigen::VectorXd & res = * new (storage) Eigen::VectorXd(nrow);
- 
-      // Copy the data
-      double * data = (double*)array->get_data();
-      for(int i=0;i<nrow;++i) 
-	res[i] = data[i];
-
-      // Stash the memory chunk pointer for later use by boost.python
-      memory->convertible = storage;
-    }
-  };
-}
-
-Eigen::VectorXd test()
-{
-  Eigen::VectorXd v = Eigen::VectorXd::Random(5);
-  std::cout << v.transpose() << std::endl;
-  return v;
-}
-
-void test2( Eigen::VectorXd v )
-{
-  std::cout << "test2: dim = " << v.size() << " ||| v[0] = " << v[0] << std::endl;
-}
-
-BOOST_PYTHON_MODULE(libeigen)
-{
-  namespace bpn = boost::numpy;
-  namespace bp = boost::python;
-
-  bpn::initialize();
-  bp::to_python_converter<Eigen::VectorXd,
-			  boopy::Eigenvec_to_python_matrix>();
-  boopy::Eigenvec_from_python_array();
-
-  bp::def("test", test);
-  bp::def("test2", test2);
-}

unittest/alpha/eigenc.cpp

-#include "eigenpy/fwd.hpp"
-#include <numpy/arrayobject.h>
-
-namespace boopy
-{
-  namespace bp = boost::python;
-
-  template <typename SCALAR>  struct NumpyEquivalentType {};
-  template <> struct NumpyEquivalentType<double>  { enum { type_code = NPY_DOUBLE };};
-  template <> struct NumpyEquivalentType<int>     { enum { type_code = NPY_INT    };};
-  template <> struct NumpyEquivalentType<float>   { enum { type_code = NPY_FLOAT  };};
-	
-  struct EigenMatrix_to_python_matrix
-  {
-    static PyObject* convert(Eigen::MatrixXd const& mat)
-    {
-      typedef Eigen::MatrixXd::Scalar T;
-
-      npy_intp shape[2] = { mat.rows(), mat.cols() };
-      PyArrayObject* pyArray = (PyArrayObject*)
-	PyArray_SimpleNew(2, shape,
-			  NumpyEquivalentType<T>::type_code);
-
-      T* pyData = (T*)PyArray_DATA(pyArray);
-      for(int i=0;i<mat.rows();++i)
-	for(int j=0;j<mat.cols();++j)
-	  pyData[i*mat.cols()+j] = mat(i,j);
-
-      return ((PyObject*)pyArray);
-    }
-  };
-  
-
-  struct EigenMatrix_from_python_array
-  {
-
-    EigenMatrix_from_python_array()
-    {
-      bp::converter::registry
-	::push_back(&convertible,
-		    &construct,
-		    bp::type_id<Eigen::MatrixXd>());
-    }
- 
-    // Determine if obj_ptr can be converted in a Eigenvec
-    static void* convertible(PyObject* obj_ptr)
-    {
-      typedef Eigen::MatrixXd::Scalar T;
-
-      if (!PyArray_Check(obj_ptr)) {
-	return 0;
-      }
-      if (PyArray_NDIM(obj_ptr) > 2) {
-	return 0;
-      }
-      if (PyArray_ObjectType(obj_ptr, 0) != NumpyEquivalentType<T>::type_code) {
-	return 0;
-      }
-      int flags = PyArray_FLAGS(obj_ptr);
-      if (!(flags & NPY_C_CONTIGUOUS)) {
-	return 0;
-      }
-      if (!(flags & NPY_ALIGNED)) {
-	return 0;
-      }
-      
-      return obj_ptr;
-    }
- 
-    // Convert obj_ptr into a Eigenvec
-    static void construct(PyObject* pyObj,
-			  bp::converter::rvalue_from_python_stage1_data* memory)
-    {
-      typedef Eigen::MatrixXd::Scalar T;
-      using namespace Eigen;
-
-      PyArrayObject * pyArray = reinterpret_cast<PyArrayObject*>(pyObj);
-      int ndims = PyArray_NDIM(pyArray);
-      assert(ndims == 2);
-
-      int dtype_size = (PyArray_DESCR(pyArray))->elsize;
-      int s1 = PyArray_STRIDE(pyArray, 0);
-      assert(s1 % dtype_size == 0);
-
-      int R = MatrixXd::RowsAtCompileTime;
-      int C = MatrixXd::ColsAtCompileTime;
-      if (R == Eigen::Dynamic) R = PyArray_DIMS(pyArray)[0];
-      else	               assert(PyArray_DIMS(pyArray)[0]==R);
-
-      if (C == Eigen::Dynamic) C = PyArray_DIMS(pyArray)[1];
-      else	               assert(PyArray_DIMS(pyArray)[1]==C);
-
-      T* pyData = reinterpret_cast<T*>(PyArray_DATA(pyArray));
-
-      void* storage = ((bp::converter::rvalue_from_python_storage<MatrixXd>*)
-		       (memory))->storage.bytes;
-      MatrixXd & mat = * new (storage) MatrixXd(R,C);
-      for(int i=0;i<R;++i) 
-	for(int j=0;j<C;++j) 
-	  mat(i,j) = pyData[i*C+j];
-
-      memory->convertible = storage;
-    }
-  };
-
-
-}
-
-Eigen::MatrixXd test()
-{
-  Eigen::MatrixXd mat = Eigen::MatrixXd::Random(5,5);
-  std::cout << "EigenMAt = " << mat << std::endl;
-  return mat;
-}
-
-void test2( Eigen::MatrixXd mat )
-{
-  std::cout << "test2: dim = " << mat.rows() << " ||| m[0,0] = " << mat(0,0) << std::endl;
-}
-
-BOOST_PYTHON_MODULE(libeigenc)
-{
-  import_array();
-  namespace bp = boost::python;
-  bp::to_python_converter<Eigen::MatrixXd,
-			  boopy::EigenMatrix_to_python_matrix>();
-  boopy::EigenMatrix_from_python_array();
-
-  bp::def("test", test);
-  bp::def("test2", test2);
-}

unittest/alpha/eigentemplate.cpp

-#include "eigenpy/fwd.hpp"
-#include <numpy/arrayobject.h>
-
-namespace boopy
-{
-  namespace bp = boost::python;
-
-  template <typename SCALAR>  struct NumpyEquivalentType {};
-  template <> struct NumpyEquivalentType<double>  { enum { type_code = NPY_DOUBLE };};
-  template <> struct NumpyEquivalentType<int>     { enum { type_code = NPY_INT    };};
-  template <> struct NumpyEquivalentType<float>   { enum { type_code = NPY_FLOAT  };};
-
-  /* --- TO PYTHON -------------------------------------------------------------- */
-  template< typename MatType >
-  struct EigenMatrix_to_python_matrix
-  {
-    static PyObject* convert(MatType const& mat)
-    {
-      typedef typename MatType::Scalar T;
-      const int R  = mat.rows(), C = mat.cols();
-
-      npy_intp shape[2] = { R,C };
-      PyArrayObject* pyArray = (PyArrayObject*)
-	PyArray_SimpleNew(2, shape,
-			  NumpyEquivalentType<T>::type_code);
-
-      T* pyData = (T*)PyArray_DATA(pyArray);
-      Eigen::Map< Eigen::Matrix<T,Eigen::Dynamic,Eigen::Dynamic,Eigen::RowMajor> > pyMatrix(pyData,R,C);
-      pyMatrix = mat;
-
-      return (PyObject*)pyArray;
-    }
-  };
-  
-  /* --- FROM PYTHON ------------------------------------------------------------ */
-  template<typename MatType>
-  struct EigenMatrix_from_python_array
-  {
-
-    EigenMatrix_from_python_array()
-    {
-      bp::converter::registry
-	::push_back(&convertible,
-		    &construct,
-		    bp::type_id<MatType>());
-    }
- 
-    // Determine if obj_ptr can be converted in a Eigenvec
-    static void* convertible(PyObject* obj_ptr)
-    {
-      typedef typename MatType::Scalar T;
-
-      if (!PyArray_Check(obj_ptr)) return 0;
-
-      std::cout << "Until here ok.   ndim = " << PyArray_NDIM(obj_ptr) << " isvec " << MatType::IsVectorAtCompileTime << std::endl;
-      if (PyArray_NDIM(obj_ptr) != 2)
-	if ( (PyArray_NDIM(obj_ptr) !=1) || (! MatType::IsVectorAtCompileTime) )
-	  return 0;
-      std::cout << "Until here ok." << std::endl;
-
-      if (PyArray_ObjectType(obj_ptr, 0) != NumpyEquivalentType<T>::type_code)
-	return 0;
-      
-      if (!(PyArray_FLAGS(obj_ptr) & NPY_ALIGNED))
-	{
-	  std::cerr << "NPY non-aligned matrices are not implemented." << std::endl;
-	  return 0;
-	}
-      
-      return obj_ptr;
-    }
- 
-    // Convert obj_ptr into a Eigenvec
-    static void construct(PyObject* pyObj,
-			  bp::converter::rvalue_from_python_stage1_data* memory)
-    {
-      typedef typename MatType::Scalar T;
-      using namespace Eigen;
-
-      std::cout << "Until here ok. Constructing..." << std::endl;
-      PyArrayObject * pyArray = reinterpret_cast<PyArrayObject*>(pyObj);
-
-      if ( PyArray_NDIM(pyArray) == 2 )
-      {
-	int R = MatType::RowsAtCompileTime;
-	int C = MatType::ColsAtCompileTime;
-	if (R == Eigen::Dynamic) R = PyArray_DIMS(pyArray)[0];
-	else	               assert(PyArray_DIMS(pyArray)[0]==R);
-	
-	if (C == Eigen::Dynamic) C = PyArray_DIMS(pyArray)[1];
-	else	               assert(PyArray_DIMS(pyArray)[1]==C);
-	
-	T* pyData = reinterpret_cast<T*>(PyArray_DATA(pyArray));
-
-	int itemsize = PyArray_ITEMSIZE(pyArray);
-	int stride1 = PyArray_STRIDE(pyArray, 0) / itemsize;
-	int stride2 = PyArray_STRIDE(pyArray, 1) / itemsize;
-	std::cout << "STRIDE = " << stride1 << " x " << stride2 << std::endl;
-	Eigen::Map<MatType,0,Eigen::Stride<Eigen::Dynamic,Eigen::Dynamic> >
-	  pyMap( pyData, R,C, Eigen::Stride<Eigen::Dynamic,Eigen::Dynamic>(stride2,stride1) );
-	std::cout << "Map = " << pyMap << std::endl;
-	
-	void* storage = ((bp::converter::rvalue_from_python_storage<MatType>*)
-			 (memory))->storage.bytes;
-	MatType & mat = * new (storage) MatType(R,C);
-	mat = pyMap; 
-
-	memory->convertible = storage;
-      }
-    else
-      {
-	int R = MatType::MaxSizeAtCompileTime, C=1;
-	if(R==Eigen::Dynamic) R =  PyArray_DIMS(pyArray)[0];
-	else                  assert(PyArray_DIMS(pyArray)[0]==R);
-
-	T* pyData = reinterpret_cast<T*>(PyArray_DATA(pyArray));
-
-	int itemsize = PyArray_ITEMSIZE(pyArray);
-	int stride = PyArray_STRIDE(pyArray, 0) / itemsize;
-	Eigen::Stride<Eigen::Dynamic,Eigen::Dynamic> s(stride,0);
-	Eigen::Map<MatType,0,Eigen::InnerStride<Eigen::Dynamic> >
-	  pyMap( pyData, R, 1, Eigen::InnerStride<Eigen::Dynamic>(stride) );
-	std::cout << "Map = " << pyMap << std::endl;
-	
-	void* storage = ((bp::converter::rvalue_from_python_storage<MatType>*)
-			 (memory))->storage.bytes;
-	MatType & mat = * new (storage) MatType(R,C);
-	mat = pyMap; 
-
-	memory->convertible = storage;
-      }
-    }
-  };
-
-
-}
-
-Eigen::MatrixXd test()
-{
-  Eigen::MatrixXd mat = Eigen::MatrixXd::Random(3,6);
-  std::cout << "EigenMAt = " << mat << std::endl;
-  return mat;
-}
-Eigen::VectorXd testVec()
-{
-  Eigen::VectorXd mat = Eigen::VectorXd::Random(6);
-  std::cout << "EigenVec = " << mat << std::endl;
-  return mat;
-}
-
-void test2( Eigen::MatrixXd mat )
-{
-  std::cout << "Test2 mat = " << mat << std::endl;
-}
-void test2Vec( Eigen::VectorXd v )
-{
-  std::cout << "Test2 vec = " << v << std::endl;
-}
-
-BOOST_PYTHON_MODULE(libeigentemplate)
-{
-  import_array();
-  namespace bp = boost::python;
-  bp::to_python_converter<Eigen::MatrixXd,
-			  boopy::EigenMatrix_to_python_matrix<Eigen::MatrixXd> >();
-  boopy::EigenMatrix_from_python_array<Eigen::MatrixXd>();
-
-  bp::to_python_converter<Eigen::VectorXd,
-   			  boopy::EigenMatrix_to_python_matrix<Eigen::VectorXd> >();
-  boopy::EigenMatrix_from_python_array<Eigen::VectorXd>();
-
-  bp::def("test", test);
-  bp::def("testVec", testVec);
-  bp::def("test2", test2);
-  bp::def("test2Vec", test2Vec);
-}

unittest/alpha/mystring.cpp

-/* Tutorial with boost::python. Using the converter to access a home-made
- * string class and bind it to the python strings. */
-
-#include <boost/python/module.hpp>
-#include <boost/python/def.hpp>
-#include <boost/python/to_python_converter.hpp>
-
-namespace homemadestring
-{
-
-  /* This is the home-made string class. */
-  class custom_string
-  {
-  public:
-    custom_string() {}
-    custom_string(std::string const& value) : value_(value) {}
-    std::string const& value() const { return value_; }
-  private:
-    std::string value_;
-  };
-
-  /* Two simple functions with this class */
-  custom_string hello() { return custom_string("Hello world."); }
-  std::size_t size(custom_string const& s) { return s.value().size(); }
-
-
-  /* From c to python converter */
-  struct custom_string_to_python_str
-  {
-    static PyObject* convert(custom_string const& s)
-    {
-      return boost::python::incref(boost::python::object(s.value()).ptr());
-    }
-  };
-
-  struct custom_string_from_python_str
-  {
-    custom_string_from_python_str()
-    {
-      boost::python::converter::registry
-	::push_back(&convertible,
-		    &construct,
-		    boost::python::type_id<custom_string>());
-    }
-
-    static void* convertible(PyObject* obj_ptr)
-    {
-      if (!PyString_Check(obj_ptr)) return 0;
-      return obj_ptr;
-    }
-
-    static void 
-    construct(PyObject* obj_ptr,
-	      boost::python::converter::rvalue_from_python_stage1_data* data)
-    {
-      const char* value = PyString_AsString(obj_ptr);
-      if (value == 0) boost::python::throw_error_already_set();
-      void* storage =
-	((boost::python::converter::rvalue_from_python_storage<custom_string>*)data)
-	->storage.bytes;
-      new (storage) custom_string(value);
-      data->convertible = storage;
-    }
-  };
-
-  void init_module()
-  {
-    using namespace boost::python;
-
-    boost::python::to_python_converter<custom_string,
-				       custom_string_to_python_str>();
-    custom_string_from_python_str();
-
-    def("hello", hello);
-    def("size", size);
-  }
-
-} // namespace homemagestring
-
-BOOST_PYTHON_MODULE(libmystring)
-{
-  homemadestring::init_module();
-}

unittest/alpha/simple.cpp

-/* Simple test with boost::python.
- * Declare and bind three function, returning char*, string, and Eigen::Vector. The last
- * function raises and error at runtime due to inadequate binding.
- */
-
-#include <string>
-
-#include "eigenpy/fwd.hpp"
-
-
-char const* testchar()
-{
-  return "Yay char!";
-}
-
-std::string teststr()
-{
-  return "Yay str!";
-}
-
-Eigen::VectorXd testeigenvec()
-{
-  Eigen::VectorXd v(555);
-  return v;
-}
-
-
-BOOST_PYTHON_MODULE(libsimple)
-{
-  using namespace boost::python;
-  def("char", testchar);
-  def("str", teststr);
-  def("eigenvec",testeigenvec);
-}

unittest/bind_optional.cpp.in

+///
+/// Copyright (c) 2023 CNRS INRIA
+///
+
+#include "eigenpy/eigenpy.hpp"
+#include "eigenpy/optional.hpp"
+#ifdef EIGENPY_WITH_CXX17_SUPPORT
+#include <optional>
+#endif
+
+#cmakedefine TEST_TYPE @TEST_TYPE@
+#define OPTIONAL TEST_TYPE
+
+typedef eigenpy::detail::nullopt_helper<OPTIONAL> none_helper;
+static auto OPT_NONE = none_helper::value();
+typedef OPTIONAL<double> opt_dbl;
+
+struct mystruct {
+  OPTIONAL<int> a;
+  opt_dbl b;
+  OPTIONAL<std::string> msg{"i am struct"};
+  mystruct() : a(OPT_NONE), b(OPT_NONE) {}
+  mystruct(int a, const opt_dbl &b = OPT_NONE) : a(a), b(b) {}
+};
+
+OPTIONAL<int> none_if_zero(int i) {
+  if (i == 0)
+    return OPT_NONE;
+  else
+    return i;
+}
+
+OPTIONAL<mystruct> create_if_true(bool flag, opt_dbl b = OPT_NONE) {
+  if (flag) {
+    return mystruct(0, b);
+  } else {
+    return OPT_NONE;
+  }
+}
+
+OPTIONAL<Eigen::MatrixXd> random_mat_if_true(bool flag) {
+  if (flag)
+    return Eigen::MatrixXd(Eigen::MatrixXd::Random(4, 4));
+  else
+    return OPT_NONE;
+}
+
+BOOST_PYTHON_MODULE(@MODNAME@) {
+  using namespace eigenpy;
+  OptionalConverter<int, OPTIONAL>::registration();
+  OptionalConverter<double, OPTIONAL>::registration();
+  OptionalConverter<std::string, OPTIONAL>::registration();
+  OptionalConverter<mystruct, OPTIONAL>::registration();
+  OptionalConverter<Eigen::MatrixXd, OPTIONAL>::registration();
+  enableEigenPy();
+
+  bp::class_<mystruct>("mystruct", bp::no_init)
+      .def(bp::init<>(bp::args("self")))
+      .def(bp::init<int, bp::optional<const opt_dbl &> >(
+          bp::args("self", "a", "b")))
+      .add_property(
+          "a",
+          bp::make_getter(&mystruct::a,
+                          bp::return_value_policy<bp::return_by_value>()),
+          bp::make_setter(&mystruct::a))
+      .add_property(
+          "b",
+          bp::make_getter(&mystruct::b,
+                          bp::return_value_policy<bp::return_by_value>()),
+          bp::make_setter(&mystruct::b))
+      .add_property(
+          "msg",
+          bp::make_getter(&mystruct::msg,
+                          bp::return_value_policy<bp::return_by_value>()),
+          bp::make_setter(&mystruct::msg));
+
+  bp::def("none_if_zero", none_if_zero, bp::args("i"));
+  bp::def("create_if_true", create_if_true,
+          (bp::arg("flag"), bp::arg("b") = OPT_NONE));
+  bp::def("random_mat_if_true", random_mat_if_true, bp::args("flag"));
+}