src/decompositions/ldlt-solver.cpp

+/*
+ * Copyright 2024 INRIA
+ */
+
+#include "eigenpy/decompositions/LDLT.hpp"
+
+namespace eigenpy {
+void exposeLDLTSolver() {
+  using namespace Eigen;
+  LDLTSolverVisitor<MatrixXd>::expose("LDLT");
+}
+}  // namespace eigenpy

src/decompositions/llt-solver.cpp

+/*
+ * Copyright 2024 INRIA
+ */
+
+#include "eigenpy/decompositions/LLT.hpp"
+
+namespace eigenpy {
+void exposeLLTSolver() {
+  using namespace Eigen;
+  LLTSolverVisitor<MatrixXd>::expose("LLT");
+}
+}  // namespace eigenpy

src/decompositions/minres-solver.cpp

+/*
+ * Copyright 2024 INRIA
+ */
+
+#include "eigenpy/decompositions/minres.hpp"
+
+namespace eigenpy {
+void exposeMINRESSolver() {
+  using namespace Eigen;
+  MINRESSolverVisitor<MatrixXd>::expose("MINRES");
+}
+}  // namespace eigenpy

src/decompositions/permutation-matrix.cpp

+/*
+ * Copyright 2024 INRIA
+ */
+
+#include "eigenpy/decompositions/PermutationMatrix.hpp"
+
+namespace eigenpy {
+void exposePermutationMatrix() {
+  using namespace Eigen;
+  PermutationMatrixVisitor<Eigen::Dynamic>::expose("PermutationMatrix");
+}
+}  // namespace eigenpy

src/decompositions/qr-solvers.cpp

+/*
+ * Copyright 2024 INRIA
+ */
+
+#include "eigenpy/decompositions/QR.hpp"
+
+namespace eigenpy {
+void exposeQRSolvers() {
+  using namespace Eigen;
+  HouseholderQRSolverVisitor<MatrixXd>::expose("HouseholderQR");
+  FullPivHouseholderQRSolverVisitor<MatrixXd>::expose("FullPivHouseholderQR");
+  ColPivHouseholderQRSolverVisitor<MatrixXd>::expose("ColPivHouseholderQR");
+  CompleteOrthogonalDecompositionSolverVisitor<MatrixXd>::expose(
+      "CompleteOrthogonalDecomposition");
+}
+}  // namespace eigenpy

src/decompositions/seigen-solver.cpp

+
+/*
+ * Copyright 2024 INRIA
+ */
+
+#include "eigenpy/decompositions/EigenSolver.hpp"
+
+namespace eigenpy {
+void exposeEigenSolver() {
+  using namespace Eigen;
+  EigenSolverVisitor<MatrixXd>::expose("EigenSolver");
+}
+}  // namespace eigenpy

src/decompositions/self-adjoint-eigen-solver.cpp

+
+/*
+ * Copyright 2024 INRIA
+ */
+
+#include "eigenpy/decompositions/SelfAdjointEigenSolver.hpp"
+
+namespace eigenpy {
+void exposeSelfAdjointEigenSolver() {
+  using namespace Eigen;
+  SelfAdjointEigenSolverVisitor<MatrixXd>::expose("SelfAdjointEigenSolver");
+}
+}  // namespace eigenpy

src/decompositions/simplicial-ldlt-solver.cpp

+/*
+ * Copyright 2024 INRIA
+ */
+
+#include "eigenpy/decompositions/sparse/LDLT.hpp"
+
+namespace eigenpy {
+void exposeSimplicialLDLTSolver() {
+  using namespace Eigen;
+  typedef SparseMatrix<double, ColMajor> ColMajorSparseMatrix;
+  SimplicialLDLTVisitor<ColMajorSparseMatrix>::expose("SimplicialLDLT");
+}
+}  // namespace eigenpy

src/decompositions/simplicial-llt-solver.cpp

+/*
+ * Copyright 2024 INRIA
+ */
+
+#include "eigenpy/decompositions/sparse/LLT.hpp"
+
+namespace eigenpy {
+void exposeSimplicialLLTSolver() {
+  using namespace Eigen;
+  typedef SparseMatrix<double, ColMajor> ColMajorSparseMatrix;
+  SimplicialLLTVisitor<ColMajorSparseMatrix>::expose("SimplicialLLT");
+}
+}  // namespace eigenpy

src/eigenpy.cpp

 /*
  * Copyright 2014-2019, CNRS
- * Copyright 2018-2021, INRIA
+ * Copyright 2018-2023, INRIA
  */
 
 #include "eigenpy/eigenpy.hpp"
+
 #include <stdlib.h>
 
-namespace eigenpy
-{
-
-  void seed(unsigned int seed_value)
-  {
-    srand(seed_value);
-  }
-
-  void exposeMatrixBool();
-  void exposeMatrixInt();
-  void exposeMatrixLong();
-  void exposeMatrixFloat();
-  void exposeMatrixDouble();
-  void exposeMatrixLongDouble();
-
-  void exposeMatrixComplexFloat();
-  void exposeMatrixComplexDouble();
-  void exposeMatrixComplexLongDouble();
-
-  /* Enable Eigen-Numpy serialization for a set of standard MatrixBase instances. */
-  void enableEigenPy()
-  {
-    using namespace Eigen;
-    import_numpy();
-    
-    Exception::registerException();
-    
-    bp::def("setNumpyType",&NumpyType::setNumpyType,
-            bp::arg("Numpy type (np.ndarray or np.matrix)"),
-            "Change the Numpy type returned by the converters from an Eigen object.");
-            
-    bp::def("getNumpyType",&NumpyType::getNumpyType,
-            "Get the Numpy type returned by the converters from an Eigen object.");
-    
-    bp::def("switchToNumpyArray",&NumpyType::switchToNumpyArray,
-            "Set the conversion from Eigen::Matrix to numpy.ndarray.");
-    
-    bp::def("switchToNumpyMatrix",&NumpyType::switchToNumpyMatrix,
-            "Set the conversion from Eigen::Matrix to numpy.matrix.");
-    
-    bp::def("sharedMemory",
-            (void (*)(const bool))NumpyType::sharedMemory,
-            bp::arg("value"),
-            "Share the memory when converting from Eigen to Numpy.");
-    
-    bp::def("sharedMemory",
-            (bool (*)())NumpyType::sharedMemory,
-            "Status of the shared memory when converting from Eigen to Numpy.\n"
-            "If True, the memory is shared when converting an Eigen::Matrix to a numpy.array.\n"
-            "Otherwise, a deep copy of the Eigen::Matrix is performed.");
-    
-    bp::def("seed",&seed,bp::arg("seed_value"),
-            "Initialize the pseudo-random number generator with the argument seed_value.");
-    
-    exposeMatrixBool();
-    exposeMatrixInt();
-    exposeMatrixLong();
-    exposeMatrixFloat();
-    exposeMatrixDouble();
-    exposeMatrixLongDouble();
-    
-    exposeMatrixComplexFloat();
-    exposeMatrixComplexDouble();
-    exposeMatrixComplexLongDouble();
-  }
-
-} // namespace eigenpy
+namespace eigenpy {
+
+void seed(unsigned int seed_value) { srand(seed_value); }
+
+void exposeMatrixBool();
+void exposeMatrixInt8();
+void exposeMatrixChar();
+void exposeMatrixUInt8();
+void exposeMatrixInt16();
+void exposeMatrixUInt16();
+void exposeMatrixInt32();
+void exposeMatrixUInt32();
+void exposeMatrixWindowsLong();
+void exposeMatrixWindowsULong();
+void exposeMatrixMacLong();
+void exposeMatrixMacULong();
+void exposeMatrixInt64();
+void exposeMatrixUInt64();
+void exposeMatrixLinuxLongLong();
+void exposeMatrixLinuxULongLong();
+void exposeMatrixFloat();
+void exposeMatrixDouble();
+void exposeMatrixLongDouble();
+
+void exposeMatrixComplexFloat();
+void exposeMatrixComplexDouble();
+void exposeMatrixComplexLongDouble();
+
+void exposeNoneType();
+void exposeTypeInfo();
+
+/* Enable Eigen-Numpy serialization for a set of standard MatrixBase instances.
+ */
+void enableEigenPy() {
+  using namespace Eigen;
+  import_numpy();
+
+  Exception::registerException();
+
+  bp::def("sharedMemory", (void (*)(const bool))NumpyType::sharedMemory,
+          bp::arg("value"),
+          "Share the memory when converting from Eigen to Numpy.");
+
+  bp::def("sharedMemory", (bool (*)())NumpyType::sharedMemory,
+          "Status of the shared memory when converting from Eigen to Numpy.\n"
+          "If True, the memory is shared when converting an Eigen::Matrix to a "
+          "numpy.array.\n"
+          "Otherwise, a deep copy of the Eigen::Matrix is performed.");
+
+  bp::def("seed", &seed, bp::arg("seed_value"),
+          "Initialize the pseudo-random number generator with the argument "
+          "seed_value.");
+
+  exposeMatrixBool();
+  exposeMatrixInt8();
+  exposeMatrixChar();
+  exposeMatrixUInt8();
+  exposeMatrixInt16();
+  exposeMatrixUInt16();
+  exposeMatrixInt32();
+  exposeMatrixUInt32();
+  exposeMatrixWindowsLong();
+  exposeMatrixWindowsULong();
+  exposeMatrixMacLong();
+  exposeMatrixMacULong();
+  exposeMatrixInt64();
+  exposeMatrixUInt64();
+  exposeMatrixLinuxLongLong();
+  exposeMatrixLinuxULongLong();
+  exposeMatrixFloat();
+  exposeMatrixDouble();
+  exposeMatrixLongDouble();
+
+  exposeMatrixComplexFloat();
+  exposeMatrixComplexDouble();
+  exposeMatrixComplexLongDouble();
+
+  exposeNoneType();
+  exposeTypeInfo();
+}
+
+bool withTensorSupport() {
+#ifdef EIGENPY_WITH_TENSOR_SUPPORT
+  return true;
+#else
+  return false;
+#endif
+}
+
+}  // namespace eigenpy

src/exception.cpp

@@ -4,33 +4,30 @@
  */
 
 #include "eigenpy/exception.hpp"
-#include "eigenpy/registration.hpp"
 
 #include <boost/python/exception_translator.hpp>
 
+#include "eigenpy/registration.hpp"
+
+namespace eigenpy {
+PyObject* Exception::pyType;
 
-namespace eigenpy
-{
-  PyObject * Exception::pyType;
+void Exception::translateException(Exception const& e) {
+  assert(NULL != pyType);
+  // Return an exception object of type pyType and value object(e).
+  PyErr_SetString(PyExc_RuntimeError, e.what());
+}
 
-  void Exception::translateException( Exception const & e )
-  {
-    assert(NULL!=pyType);
-    // Return an exception object of type pyType and value object(e).
-    PyErr_SetString(PyExc_RuntimeError, e.what());
-  }
+void Exception::registerException() {
+  if (check_registration<eigenpy::Exception>()) return;
 
-  void Exception::registerException()
-  {
-    if(check_registration<eigenpy::Exception>()) return;
-    
-    pyType = boost::python::class_<eigenpy::Exception>
-      ("Exception",boost::python::init<std::string>())
-      .add_property("message", &eigenpy::Exception::copyMessage)
-      .ptr();
+  pyType = boost::python::class_<eigenpy::Exception>(
+               "Exception", boost::python::init<std::string>())
+               .add_property("message", &eigenpy::Exception::copyMessage)
+               .ptr();
 
-    boost::python::register_exception_translator<eigenpy::Exception>
-      (&eigenpy::Exception::translateException);
-  }
+  boost::python::register_exception_translator<eigenpy::Exception>(
+      &eigenpy::Exception::translateException);
+}
 
-} // namespace eigenpy
+}  // namespace eigenpy

src/geometry-conversion.cpp

 /*
  * Copyright 2014-2019, CNRS
- * Copyright 2018-2019, INRIA
+ * Copyright 2018-2023, INRIA
  */
 
-#include "eigenpy/memory.hpp"
-#include "eigenpy/geometry.hpp"
 #include "eigenpy/geometry-conversion.hpp"
+#include "eigenpy/geometry.hpp"
 
-namespace eigenpy
-{
-  void exposeGeometryConversion()
-  {
-    EulerAnglesConvertor<double>::expose();
-  }
-} // namespace eigenpy
+namespace eigenpy {
+void exposeGeometryConversion() { EulerAnglesConvertor<double>::expose(); }
+}  // namespace eigenpy

src/matrix-bool.cpp

@@ -4,11 +4,9 @@
 
 #include "eigenpy/eigenpy.hpp"
 
-namespace eigenpy
-{
-  void exposeMatrixBool()
-  {
-    exposeType<bool>();
-    exposeType<bool,Eigen::RowMajor>();
-  }
+namespace eigenpy {
+void exposeMatrixBool() {
+  exposeType<bool>();
+  exposeType<bool, Eigen::RowMajor>();
 }
+}  // namespace eigenpy

src/matrix-char.cpp

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

src/matrix-complex-double.cpp

@@ -4,11 +4,9 @@
 
 #include "eigenpy/eigenpy.hpp"
 
-namespace eigenpy
-{
-  void exposeMatrixComplexDouble()
-  {
-    exposeType<std::complex<double> >();
-    exposeType<std::complex<double>,Eigen::RowMajor>();
-  }
+namespace eigenpy {
+void exposeMatrixComplexDouble() {
+  exposeType<std::complex<double> >();
+  exposeType<std::complex<double>, Eigen::RowMajor>();
 }
+}  // namespace eigenpy

src/matrix-complex-float.cpp

@@ -4,11 +4,9 @@
 
 #include "eigenpy/eigenpy.hpp"
 
-namespace eigenpy
-{
-  void exposeMatrixComplexFloat()
-  {
-    exposeType<std::complex<float> >();
-    exposeType<std::complex<float>,Eigen::RowMajor>();
-  }
+namespace eigenpy {
+void exposeMatrixComplexFloat() {
+  exposeType<std::complex<float> >();
+  exposeType<std::complex<float>, Eigen::RowMajor>();
 }
+}  // namespace eigenpy

src/matrix-complex-long-double.cpp

@@ -4,11 +4,9 @@
 
 #include "eigenpy/eigenpy.hpp"
 
-namespace eigenpy
-{
-  void exposeMatrixComplexLongDouble()
-  {
-    exposeType<std::complex<long double> >();
-    exposeType<std::complex<long double>,Eigen::RowMajor>();
-  }
+namespace eigenpy {
+void exposeMatrixComplexLongDouble() {
+  exposeType<std::complex<long double> >();
+  exposeType<std::complex<long double>, Eigen::RowMajor>();
 }
+}  // namespace eigenpy

src/matrix-double.cpp

@@ -4,11 +4,9 @@
 
 #include "eigenpy/eigenpy.hpp"
 
-namespace eigenpy
-{
-  void exposeMatrixDouble()
-  {
-    exposeType<double>();
-    exposeType<double,Eigen::RowMajor>();
-  }
+namespace eigenpy {
+void exposeMatrixDouble() {
+  exposeType<double>();
+  exposeType<double, Eigen::RowMajor>();
 }
+}  // namespace eigenpy

src/matrix-float.cpp

@@ -4,11 +4,9 @@
 
 #include "eigenpy/eigenpy.hpp"
 
-namespace eigenpy
-{
-  void exposeMatrixFloat()
-  {
-    exposeType<float>();
-    exposeType<float,Eigen::RowMajor>();
-  }
+namespace eigenpy {
+void exposeMatrixFloat() {
+  exposeType<float>();
+  exposeType<float, Eigen::RowMajor>();
 }
+}  // namespace eigenpy

src/matrix-int.cpp

-/*
- * Copyright 2020 INRIA
- */
-
-#include "eigenpy/eigenpy.hpp"
-
-namespace eigenpy
-{
-  void exposeMatrixInt()
-  {
-    exposeType<int>();
-    exposeType<int,Eigen::RowMajor>();
-  }
-}