src/matrix-uint64.cpp

+/*
+ * Copyright 2020 INRIA
+ */
+
+#include "eigenpy/eigenpy.hpp"
+
+#include <cstdint>
+
+namespace eigenpy {
+void exposeMatrixUInt64() {
+  exposeType<uint64_t>();
+  exposeType<uint64_t, Eigen::RowMajor>();
+}
+}  // namespace eigenpy

src/matrix-uint8.cpp

+/*
+ * Copyright 2020 INRIA
+ */
+
+#include "eigenpy/eigenpy.hpp"
+
+#include <cstdint>
+
+namespace eigenpy {
+void exposeMatrixUInt8() {
+  exposeType<std::uint8_t>();
+  exposeType<std::uint8_t, Eigen::RowMajor>();
+}
+}  // namespace eigenpy

src/matrix-windows-long.cpp

+/*
+ * Copyright 2024 INRIA
+ */
+
+#include "eigenpy/eigenpy.hpp"
+
+namespace eigenpy {
+void exposeMatrixWindowsLong() {
+// On Windows, long is a 32 bytes type but it's a different type than int
+#ifdef WIN32
+  exposeType<long>();
+  exposeType<long, Eigen::RowMajor>();
+#endif  // WIN32
+}
+}  // namespace eigenpy

src/matrix-windows-ulong.cpp

+/*
+ * Copyright 2024 INRIA
+ */
+
+#include "eigenpy/eigenpy.hpp"
+
+namespace eigenpy {
+void exposeMatrixWindowsULong() {
+// On Windows, long is a 32 bytes type but it's a different type than int
+#ifdef WIN32
+  exposeType<unsigned long>();
+  exposeType<unsigned long, Eigen::RowMajor>();
+#endif  // WIN32
+}
+}  // namespace eigenpy

src/numpy.cpp

 /*
- * Copyright 2020-2022 INRIA
+ * Copyright 2020-2024 INRIA
  */
 
 #include "eigenpy/numpy.hpp"
@@ -14,7 +14,12 @@ void import_numpy() {
 }
 
 int PyArray_TypeNum(PyTypeObject* type) {
-  return PyArray_TypeNumFromName(const_cast<char*>(type->tp_name));
+  PyArray_Descr* descr =
+      PyArray_DescrFromTypeObject(reinterpret_cast<PyObject*>(type));
+  if (descr == NULL) {
+    return NPY_NOTYPE;
+  }
+  return descr->type_num;
 }
 
 #if defined _WIN32 || defined __CYGWIN__
@@ -52,7 +57,7 @@ void call_PyArray_InitArrFuncs(PyArray_ArrFuncs* funcs) {
   PyArray_InitArrFuncs(funcs);
 }
 
-int call_PyArray_RegisterDataType(PyArray_Descr* dtype) {
+int call_PyArray_RegisterDataType(PyArray_DescrProto* dtype) {
   return PyArray_RegisterDataType(dtype);
 }
 

src/register.cpp

@@ -14,6 +14,17 @@ PyArray_Descr* Register::getPyArrayDescr(PyTypeObject* py_type_ptr) {
     return NULL;
 }
 
+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);
+}
+
 bool Register::isRegistered(PyTypeObject* py_type_ptr) {
   if (getPyArrayDescr(py_type_ptr) != NULL)
     return true;
@@ -52,9 +63,8 @@ int Register::registerNewType(
     throw std::invalid_argument("PyType_Ready fails to initialize input type.");
   }
 
-  PyArray_Descr* descr_ptr =
-      new PyArray_Descr(*call_PyArray_DescrFromType(NPY_OBJECT));
-  PyArray_Descr& descr = *descr_ptr;
+  PyArray_DescrProto* descr_ptr = new PyArray_DescrProto();
+  PyArray_DescrProto& descr = *descr_ptr;
   descr.typeobj = py_type_ptr;
   descr.kind = 'V';
   descr.byteorder = '=';
@@ -81,13 +91,14 @@ int Register::registerNewType(
   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*)descr_ptr) < 0) {
+                           (PyObject*)new_descr) < 0) {
     throw std::invalid_argument("PyDict_SetItemString fails.");
   }
 

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>

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

unittest/CMakeLists.txt

 #
-# Copyright (c) 2014-2019 CNRS Copyright (c) 2018-2023 INRIA
+# Copyright (c) 2014-2019 CNRS Copyright (c) 2018-2024 INRIA
 #
 
-macro(ADD_LIB_UNIT_TEST test)
+function(ADD_LIB_UNIT_TEST test)
   create_ctest_build_tests_target()
+  set(test_target ${PROJECT_NAME}-${test})
 
   if(BUILD_TESTING)
-    add_library(${test} SHARED "${test}.cpp")
-  else(BUILD_TESTING)
-    add_library(${test} SHARED EXCLUDE_FROM_ALL "${test}.cpp")
-  endif(BUILD_TESTING)
-
-  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})
+    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} PROPERTIES DEPENDS ctest_build_tests)
+    set_tests_properties(${test_target} PROPERTIES DEPENDS ctest_build_tests)
   endif(NOT BUILD_TESTING)
-endmacro(ADD_LIB_UNIT_TEST)
+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")
@@ -38,82 +55,154 @@ 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)
 
-function(config_bind_optional tagname opttype)
-  set(MODNAME bind_optional_${tagname})
-  set(OPTIONAL ${opttype})
-  configure_file(bind_optional.cpp.in ${MODNAME}.cpp)
+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()
 
-  set(py_file test_optional_${tagname}.py)
-  configure_file(python/test_optional.py.in
+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})
-  add_python_unit_test("py-optional-${tagname}" "unittest/python/${py_file}"
-                       "unittest")
+  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_bind_optional(boost "boost::optional")
+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_bind_optional(std "std::optional")
+  config_test(bind_optional std "std::optional")
 endif()
 
 add_lib_unit_test(bind_virtual_factory)
 
-add_python_unit_test("py-matrix" "unittest/python/test_matrix.py" "unittest")
+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_unit_test("py-tensor" "unittest/python/test_tensor.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_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_unit_test("py-user-type" "unittest/python/test_user_type.py"
-                       "unittest")
+  add_python_lib_unit_test("py-user-type" "unittest/python/test_user_type.py")
 endif()
 
-add_python_unit_test("py-dimensions" "unittest/python/test_dimensions.py"
-                     "python;unittest")
-set_tests_properties("py-dimensions" PROPERTIES DEPENDS ${PYWRAP})
+add_python_eigenpy_lib_unit_test("py-dimensions"
+                                 "unittest/python/test_dimensions.py")
 
-add_python_unit_test("py-version" "unittest/python/test_version.py"
-                     "python;unittest")
-set_tests_properties("py-version" PROPERTIES DEPENDS ${PYWRAP})
+add_python_eigenpy_lib_unit_test("py-version" "unittest/python/test_version.py")
 
-add_python_unit_test("py-eigen-solver" "unittest/python/test_eigen_solver.py"
-                     "python;unittest")
-set_tests_properties("py-eigen-solver" PROPERTIES DEPENDS ${PYWRAP})
+add_python_eigenpy_lib_unit_test("py-eigen-solver"
+                                 "unittest/python/test_eigen_solver.py")
 
-add_python_unit_test(
+add_python_eigenpy_lib_unit_test(
   "py-self-adjoint-eigen-solver"
-  "unittest/python/test_self_adjoint_eigen_solver.py" "python;unittest")
-set_tests_properties("py-self-adjoint-eigen-solver" PROPERTIES DEPENDS
-                                                               ${PYWRAP})
+  "unittest/python/test_self_adjoint_eigen_solver.py")
 
-add_python_unit_test("py-LLT" "unittest/python/test_LLT.py" "python;unittest")
-set_tests_properties("py-LLT" PROPERTIES DEPENDS ${PYWRAP})
+add_python_eigenpy_lib_unit_test("py-LLT" "unittest/python/test_LLT.py")
 
-add_python_unit_test("py-LDLT" "unittest/python/test_LDLT.py" "python;unittest")
-set_tests_properties("py-LDLT" PROPERTIES DEPENDS ${PYWRAP})
+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_unit_test("py-MINRES" "unittest/python/test_MINRES.py"
-                       "python;unittest")
-  set_tests_properties("py-MINRES" PROPERTIES DEPENDS ${PYWRAP})
+  add_python_eigenpy_lib_unit_test("py-MINRES" "unittest/python/test_MINRES.py")
 endif(NOT WIN32)
 
-add_python_unit_test("py-std-vector" "unittest/python/test_std_vector.py"
-                     "python;unittest")
-set_tests_properties("py-std-vector" PROPERTIES DEPENDS ${PYWRAP})
+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_unit_test("py-user-struct" "unittest/python/test_user_struct.py"
-                     "python;unittest")
-set_tests_properties("py-user-struct" PROPERTIES DEPENDS ${PYWRAP})
+add_python_lib_unit_test("py-std-map" "unittest/python/test_std_map.py")
 
-add_python_unit_test("py-bind-virtual" "unittest/python/test_bind_virtual.py"
-                     "python;unittest")
-set_tests_properties("py-bind-virtual" PROPERTIES DEPENDS ${PYWRAP})
+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"
+    )
+
+    add_python_eigenpy_unit_test(
+      "py-CholmodSupernodalLLT"
+      "unittest/python/decompositions/sparse/cholmod/test_CholmodSupernodalLLT.py"
+    )
+  endif(BUILD_WITH_CHOLMOD_SUPPORT)
+
+  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/bind_optional.cpp.in

@@ -8,7 +8,8 @@
 #include <optional>
 #endif
 
-#cmakedefine OPTIONAL @OPTIONAL@
+#cmakedefine TEST_TYPE @TEST_TYPE@
+#define OPTIONAL TEST_TYPE
 
 typedef eigenpy::detail::nullopt_helper<OPTIONAL> none_helper;
 static auto OPT_NONE = none_helper::value();
@@ -74,6 +75,7 @@ BOOST_PYTHON_MODULE(@MODNAME@) {
           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("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"));
 }

unittest/bind_virtual_factory.cpp

@@ -72,7 +72,10 @@ struct VirtualClassWrapper : MyVirtualClass, bp::wrapper<MyVirtualClass> {
   }
 
   shared_ptr<MyVirtualData> createData() const override {
-    if (bp::override fo = this->get_override("createData")) return fo();
+    if (bp::override fo = this->get_override("createData")) {
+      bp::object result = fo().as<bp::object>();
+      return bp::extract<shared_ptr<MyVirtualData> >(result);
+    }
     return default_createData();
   }
 

unittest/complex.cpp

@@ -69,17 +69,19 @@ BOOST_PYTHON_MODULE(complex) {
   bp::def("ascomplex",
           ascomplex<long double, Eigen::Dynamic, Eigen::Dynamic, 0>);
 
-  bp::def("real", (MatrixXf(*)(const Eigen::MatrixBase<MatrixXcf> &)) &
-                      real<MatrixXcf>);
-  bp::def("real", (MatrixXd(*)(const Eigen::MatrixBase<MatrixXcd> &)) &
-                      real<MatrixXcd>);
-  bp::def("real", (MatrixXld(*)(const Eigen::MatrixBase<MatrixXcld> &)) &
-                      real<MatrixXcld>);
+  bp::def("real",
+          (MatrixXf(*)(const Eigen::MatrixBase<MatrixXcf> &))&real<MatrixXcf>);
+  bp::def("real",
+          (MatrixXd(*)(const Eigen::MatrixBase<MatrixXcd> &))&real<MatrixXcd>);
+  bp::def(
+      "real",
+      (MatrixXld(*)(const Eigen::MatrixBase<MatrixXcld> &))&real<MatrixXcld>);
 
-  bp::def("imag", (MatrixXf(*)(const Eigen::MatrixBase<MatrixXcf> &)) &
-                      imag<MatrixXcf>);
-  bp::def("imag", (MatrixXd(*)(const Eigen::MatrixBase<MatrixXcd> &)) &
-                      imag<MatrixXcd>);
-  bp::def("imag", (MatrixXld(*)(const Eigen::MatrixBase<MatrixXcld> &)) &
-                      imag<MatrixXcld>);
+  bp::def("imag",
+          (MatrixXf(*)(const Eigen::MatrixBase<MatrixXcf> &))&imag<MatrixXcf>);
+  bp::def("imag",
+          (MatrixXd(*)(const Eigen::MatrixBase<MatrixXcd> &))&imag<MatrixXcd>);
+  bp::def(
+      "imag",
+      (MatrixXld(*)(const Eigen::MatrixBase<MatrixXcld> &))&imag<MatrixXcld>);
 }

unittest/deprecation_policy.cpp

+#include "eigenpy/eigenpy.hpp"
+#include "eigenpy/deprecation-policy.hpp"
+
+#include <iostream>
+
+namespace bp = boost::python;
+using eigenpy::DeprecationType;
+
+void some_deprecated_function() {
+  std::cout << "Calling this should produce a warning" << std::endl;
+}
+
+void some_future_deprecated_function() {
+  std::cout
+      << "Calling this should produce a warning about a future deprecation"
+      << std::endl;
+}
+
+class X {
+ public:
+  void deprecated_member_function() {}
+};
+
+BOOST_PYTHON_MODULE(deprecation_policy) {
+  bp::def("some_deprecated_function", some_deprecated_function,
+          eigenpy::deprecated_function<DeprecationType::DEPRECATION>());
+  bp::def("some_future_deprecated_function", some_future_deprecated_function,
+          eigenpy::deprecated_function<DeprecationType::FUTURE>());
+
+  bp::class_<X>("X", bp::init<>(bp::args("self")))
+      .def("deprecated_member_function", &X::deprecated_member_function,
+           eigenpy::deprecated_member<>());
+}

unittest/matrix.cpp

@@ -132,6 +132,11 @@ ReturnMatrix copy(const Eigen::MatrixBase<Matrix>& mat) {
   return mat;
 }
 
+template <typename Matrix>
+Matrix copy_same(const Eigen::MatrixBase<Matrix>& mat) {
+  return mat;
+}
+
 BOOST_PYTHON_MODULE(matrix) {
   using namespace Eigen;
   namespace bp = boost::python;
@@ -190,4 +195,39 @@ BOOST_PYTHON_MODULE(matrix) {
           copy<RowMajorMatrixXd, RowMajorMatrixXd>);
   bp::def("asRowMajorFromRowMajorVector",
           copy<Eigen::RowVectorXd, Eigen::RowVectorXd>);
+
+  bp::def("copyBoolToBool", copy_same<Eigen::Matrix<bool, -1, -1> >);
+
+  bp::def("copyInt8ToInt8", copy_same<Eigen::Matrix<int8_t, -1, -1> >);
+  bp::def("copyCharToChar", copy_same<Eigen::Matrix<char, -1, -1> >);
+  bp::def("copyUCharToUChar", copy_same<Eigen::Matrix<unsigned char, -1, -1> >);
+
+  bp::def("copyInt16ToInt16", copy_same<Eigen::Matrix<int16_t, -1, -1> >);
+  bp::def("copyUInt16ToUInt16", copy_same<Eigen::Matrix<uint16_t, -1, -1> >);
+
+  bp::def("copyInt32ToInt32", copy_same<Eigen::Matrix<int32_t, -1, -1> >);
+  bp::def("copyUInt32ToUInt32", copy_same<Eigen::Matrix<uint32_t, -1, -1> >);
+
+  bp::def("copyInt64ToInt64", copy_same<Eigen::Matrix<int64_t, -1, -1> >);
+  bp::def("copyUInt64ToUInt64", copy_same<Eigen::Matrix<uint64_t, -1, -1> >);
+
+  bp::def("copyLongToLong", copy_same<Eigen::Matrix<long, -1, -1> >);
+  bp::def("copyULongToULong", copy_same<Eigen::Matrix<unsigned long, -1, -1> >);
+
+  bp::def("copyLongLongToLongLong",
+          copy_same<Eigen::Matrix<long long, -1, -1> >);
+  bp::def("copyULongLongToULongLong",
+          copy_same<Eigen::Matrix<unsigned long long, -1, -1> >);
+
+  bp::def("copyFloatToFloat", copy_same<Eigen::Matrix<float, -1, -1> >);
+  bp::def("copyDoubleToDouble", copy_same<Eigen::Matrix<double, -1, -1> >);
+  bp::def("copyLongDoubleToLongDouble",
+          copy_same<Eigen::Matrix<long double, -1, -1> >);
+
+  bp::def("copyCFloatToCFloat",
+          copy_same<Eigen::Matrix<std::complex<float>, -1, -1> >);
+  bp::def("copyCDoubleToCDouble",
+          copy_same<Eigen::Matrix<std::complex<double>, -1, -1> >);
+  bp::def("copyCLongDoubleToCLongDouble",
+          copy_same<Eigen::Matrix<std::complex<long double>, -1, -1> >);
 }

unittest/multiple_registration.cpp

+#include "eigenpy/registration.hpp"
+#include <cstdio>
+
+namespace bp = boost::python;
+
+class X {
+ public:
+  X() {}
+  void operator()() { printf("DOOT\n"); }
+};
+
+class X_wrapper : public X, bp::wrapper<X> {
+ public:
+  static void expose() {
+    if (!eigenpy::register_symbolic_link_to_registered_type<X>()) {
+      bp::class_<X>("X", bp::init<>()).def("__call__", &X::operator());
+    }
+  }
+};
+
+BOOST_PYTHON_MODULE(multiple_registration) {
+  X_wrapper::expose();
+  X_wrapper::expose();
+  X_wrapper::expose();
+  X_wrapper::expose();
+  X_wrapper::expose();
+  X_wrapper::expose();
+}

unittest/python/decompositions/sparse/cholmod/test_CholmodSimplicialLDLT.py

+import numpy as np
+from scipy.sparse import csc_matrix
+
+import eigenpy
+
+dim = 100
+rng = np.random.default_rng()
+A = rng.random((dim, dim))
+A = (A + A.T) * 0.5 + np.diag(10.0 + rng.random(dim))
+
+A = csc_matrix(A)
+
+llt = eigenpy.CholmodSimplicialLDLT(A)
+
+assert llt.info() == eigenpy.ComputationInfo.Success
+
+X = rng.random((dim, 20))
+B = A.dot(X)
+X_est = llt.solve(B)
+assert eigenpy.is_approx(X, X_est)
+assert eigenpy.is_approx(A.dot(X_est), B)
+
+llt.analyzePattern(A)
+llt.factorize(A)

unittest/python/decompositions/sparse/cholmod/test_CholmodSimplicialLLT.py

+import numpy as np
+from scipy.sparse import csc_matrix
+
+import eigenpy
+
+dim = 100
+rng = np.random.default_rng()
+
+A = rng.random((dim, dim))
+A = (A + A.T) * 0.5 + np.diag(10.0 + rng.random(dim))
+
+A = csc_matrix(A)
+
+llt = eigenpy.CholmodSimplicialLLT(A)
+
+assert llt.info() == eigenpy.ComputationInfo.Success
+
+X = rng.random((dim, 20))
+B = A.dot(X)
+X_est = llt.solve(B)
+assert eigenpy.is_approx(X, X_est)
+assert eigenpy.is_approx(A.dot(X_est), B)
+
+llt.analyzePattern(A)
+llt.factorize(A)

unittest/python/decompositions/sparse/cholmod/test_CholmodSupernodalLLT.py

+import numpy as np
+from scipy.sparse import csc_matrix
+
+import eigenpy
+
+dim = 100
+rng = np.random.default_rng()
+
+A = rng.random((dim, dim))
+A = (A + A.T) * 0.5 + np.diag(10.0 + rng.random(dim))
+
+A = csc_matrix(A)
+
+llt = eigenpy.CholmodSupernodalLLT(A)
+
+assert llt.info() == eigenpy.ComputationInfo.Success
+
+X = rng.random((dim, 20))
+B = A.dot(X)
+X_est = llt.solve(B)
+assert eigenpy.is_approx(X, X_est)
+assert eigenpy.is_approx(A.dot(X_est), B)
+
+llt.analyzePattern(A)
+llt.factorize(A)

unittest/python/decompositions/sparse/test_Accelerate.py

+import numpy as np
+from scipy.sparse import csc_matrix
+
+import eigenpy
+
+rng = np.random.default_rng()
+
+
+def test(SolverType: type):
+    dim = 100
+    A = rng.random((dim, dim))
+    A = (A + A.T) * 0.5 + np.diag(10.0 + rng.random(dim))
+
+    A = csc_matrix(A)
+
+    llt = SolverType(A)
+
+    assert llt.info() == eigenpy.ComputationInfo.Success
+
+    X = rng.random((dim, 20))
+    B = A.dot(X)
+    X_est = llt.solve(B)
+    #    import pdb; pdb.set_trace()
+    assert eigenpy.is_approx(X, X_est)
+    assert eigenpy.is_approx(A.dot(X_est), B)
+
+    llt.analyzePattern(A)
+    llt.factorize(A)
+
+
+test(eigenpy.AccelerateLLT)
+test(eigenpy.AccelerateLDLT)
+test(eigenpy.AccelerateLDLTUnpivoted)
+test(eigenpy.AccelerateLDLTSBK)
+test(eigenpy.AccelerateLDLTTPP)
+test(eigenpy.AccelerateQR)
+# test(eigenpy.AccelerateCholeskyAtA) # This test is not passing. Seems there is a bug in Eigen with the support of Accelerate.