src/decompositions/accelerate.cpp

+/*
+ * Copyright 2024 INRIA
+ */
+
+#include "eigenpy/fwd.hpp"
+#include "eigenpy/decompositions/decompositions.hpp"
+
+#include "eigenpy/decompositions/sparse/accelerate/accelerate.hpp"
+
+namespace eigenpy {
+
+void exposeAccelerate() {
+  using namespace Eigen;
+
+  typedef Eigen::SparseMatrix<double, Eigen::ColMajor> ColMajorSparseMatrix;
+  //  typedef Eigen::SparseMatrix<double,Eigen::RowMajor> RowMajorSparseMatrix;
+
+  bp::enum_<SparseOrder_t>("SparseOrder")
+      .value("SparseOrderUser", SparseOrderUser)
+      .value("SparseOrderAMD", SparseOrderAMD)
+      .value("SparseOrderMetis", SparseOrderMetis)
+      .value("SparseOrderCOLAMD", SparseOrderCOLAMD);
+
+#define EXPOSE_ACCELERATE_DECOMPOSITION(name, doc)            \
+  AccelerateImplVisitor<name<ColMajorSparseMatrix> >::expose( \
+      EIGENPY_STRINGIZE(name), doc)
+
+  EXPOSE_ACCELERATE_DECOMPOSITION(
+      AccelerateLLT,
+      "A direct Cholesky (LLT) factorization and solver based on Accelerate.");
+  EXPOSE_ACCELERATE_DECOMPOSITION(AccelerateLDLT,
+                                  "The default Cholesky (LDLT) factorization "
+                                  "and solver based on Accelerate.");
+  EXPOSE_ACCELERATE_DECOMPOSITION(
+      AccelerateLDLTUnpivoted,
+      "A direct Cholesky-like LDL^T factorization and solver based on "
+      "Accelerate with only 1x1 pivots and no pivoting.");
+  EXPOSE_ACCELERATE_DECOMPOSITION(
+      AccelerateLDLTSBK,
+      "A direct Cholesky (LDLT) factorization and solver based on Accelerate "
+      "with Supernode Bunch-Kaufman and static pivoting.");
+  EXPOSE_ACCELERATE_DECOMPOSITION(
+      AccelerateLDLTTPP,
+      "A direct Cholesky (LDLT) factorization and solver based on Accelerate "
+      "with full threshold partial pivoting.");
+  EXPOSE_ACCELERATE_DECOMPOSITION(
+      AccelerateQR, "A QR factorization and solver based on Accelerate.");
+  EXPOSE_ACCELERATE_DECOMPOSITION(
+      AccelerateCholeskyAtA,
+      "A QR factorization and solver based on Accelerate without storing Q "
+      "(equivalent to A^TA = R^T R).");
+}
+}  // namespace eigenpy

src/decompositions/cholmod.cpp

+/*
+ * Copyright 2024 INRIA
+ */
+
+#include "eigenpy/fwd.hpp"
+#include "eigenpy/decompositions/decompositions.hpp"
+
+#include "eigenpy/decompositions/sparse/cholmod/CholmodSimplicialLLT.hpp"
+#include "eigenpy/decompositions/sparse/cholmod/CholmodSimplicialLDLT.hpp"
+#include "eigenpy/decompositions/sparse/cholmod/CholmodSupernodalLLT.hpp"
+
+namespace eigenpy {
+
+void exposeCholmod() {
+  using namespace Eigen;
+
+  typedef Eigen::SparseMatrix<double, Eigen::ColMajor> ColMajorSparseMatrix;
+  //  typedef Eigen::SparseMatrix<double,Eigen::RowMajor> RowMajorSparseMatrix;
+
+  bp::enum_<CholmodMode>("CholmodMode")
+      .value("CholmodAuto", CholmodAuto)
+      .value("CholmodSimplicialLLt", CholmodSimplicialLLt)
+      .value("CholmodSupernodalLLt", CholmodSupernodalLLt)
+      .value("CholmodLDLt", CholmodLDLt);
+
+  CholmodSimplicialLLTVisitor<ColMajorSparseMatrix>::expose(
+      "CholmodSimplicialLLT");
+  CholmodSimplicialLDLTVisitor<ColMajorSparseMatrix>::expose(
+      "CholmodSimplicialLDLT");
+  CholmodSupernodalLLTVisitor<ColMajorSparseMatrix>::expose(
+      "CholmodSupernodalLLT");
+}
+}  // namespace eigenpy

src/decompositions/decompositions.cpp

 /*
- * Copyright 2020-2021 INRIA
+ * Copyright 2020-2024 INRIA
  */
 
 #include "eigenpy/decompositions/decompositions.hpp"
 
-#include "eigenpy/decompositions/EigenSolver.hpp"
-#include "eigenpy/decompositions/LDLT.hpp"
-#include "eigenpy/decompositions/LLT.hpp"
-#include "eigenpy/decompositions/SelfAdjointEigenSolver.hpp"
-#include "eigenpy/decompositions/minres.hpp"
 #include "eigenpy/fwd.hpp"
 
 namespace eigenpy {
+
+void exposeEigenSolver();
+void exposeSelfAdjointEigenSolver();
+void exposeLLTSolver();
+void exposeLDLTSolver();
+void exposeQRSolvers();
+void exposeMINRESSolver();
+void exposeSimplicialLLTSolver();
+void exposeSimplicialLDLTSolver();
+void exposePermutationMatrix();
+
 void exposeDecompositions() {
   using namespace Eigen;
 
-  EigenSolverVisitor<MatrixXd>::expose("EigenSolver");
-  SelfAdjointEigenSolverVisitor<MatrixXd>::expose("SelfAdjointEigenSolver");
-  LLTSolverVisitor<MatrixXd>::expose("LLT");
-  LDLTSolverVisitor<MatrixXd>::expose("LDLT");
-
-  MINRESSolverVisitor<MatrixXd>::expose("MINRES");
+  exposeEigenSolver();
+  exposeSelfAdjointEigenSolver();
+  exposeLLTSolver();
+  exposeLDLTSolver();
+  exposeQRSolvers();
+  exposeMINRESSolver();
 
   {
     bp::enum_<DecompositionOptions>("DecompositionOptions")
@@ -34,5 +40,19 @@ void exposeDecompositions() {
         .value("ABx_lx", ABx_lx)
         .value("BAx_lx", BAx_lx);
   }
+
+  // Expose sparse decompositions
+  exposeSimplicialLLTSolver();
+  exposeSimplicialLDLTSolver();
+
+  exposePermutationMatrix();
+
+#ifdef EIGENPY_WITH_CHOLMOD_SUPPORT
+  exposeCholmod();
+#endif
+
+#ifdef EIGENPY_WITH_ACCELERATE_SUPPORT
+  exposeAccelerate();
+#endif
 }
 }  // namespace eigenpy

src/decompositions/eigen-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/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"
@@ -12,8 +12,21 @@ namespace eigenpy {
 void seed(unsigned int seed_value) { srand(seed_value); }
 
 void exposeMatrixBool();
-void exposeMatrixInt();
-void exposeMatrixLong();
+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();
@@ -22,6 +35,9 @@ void exposeMatrixComplexFloat();
 void exposeMatrixComplexDouble();
 void exposeMatrixComplexLongDouble();
 
+void exposeNoneType();
+void exposeTypeInfo();
+
 /* Enable Eigen-Numpy serialization for a set of standard MatrixBase instances.
  */
 void enableEigenPy() {
@@ -30,20 +46,6 @@ void enableEigenPy() {
 
   Exception::registerException();
 
-  bp::def(
-      "setNumpyType", &NumpyType::setNumpyType, bp::arg("numpy_type"),
-      "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.");
@@ -59,8 +61,21 @@ void enableEigenPy() {
           "seed_value.");
 
   exposeMatrixBool();
-  exposeMatrixInt();
-  exposeMatrixLong();
+  exposeMatrixInt8();
+  exposeMatrixChar();
+  exposeMatrixUInt8();
+  exposeMatrixInt16();
+  exposeMatrixUInt16();
+  exposeMatrixInt32();
+  exposeMatrixUInt32();
+  exposeMatrixWindowsLong();
+  exposeMatrixWindowsULong();
+  exposeMatrixMacLong();
+  exposeMatrixMacULong();
+  exposeMatrixInt64();
+  exposeMatrixUInt64();
+  exposeMatrixLinuxLongLong();
+  exposeMatrixLinuxULongLong();
   exposeMatrixFloat();
   exposeMatrixDouble();
   exposeMatrixLongDouble();
@@ -68,6 +83,17 @@ void enableEigenPy() {
   exposeMatrixComplexFloat();
   exposeMatrixComplexDouble();
   exposeMatrixComplexLongDouble();
+
+  exposeNoneType();
+  exposeTypeInfo();
+}
+
+bool withTensorSupport() {
+#ifdef EIGENPY_WITH_TENSOR_SUPPORT
+  return true;
+#else
+  return false;
+#endif
 }
 
 }  // 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-int16.cpp

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

src/matrix-long.cpp → src/matrix-int32.cpp

@@ -4,9 +4,11 @@
 
 #include "eigenpy/eigenpy.hpp"
 
+#include <cstdint>
+
 namespace eigenpy {
-void exposeMatrixLong() {
-  exposeType<long>();
-  exposeType<long, Eigen::RowMajor>();
+void exposeMatrixInt32() {
+  exposeType<int32_t>();
+  exposeType<int32_t, Eigen::RowMajor>();
 }
 }  // namespace eigenpy

src/matrix-int64.cpp

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

src/matrix-int.cpp → src/matrix-int8.cpp

@@ -4,9 +4,11 @@
 
 #include "eigenpy/eigenpy.hpp"
 
+#include <cstdint>
+
 namespace eigenpy {
-void exposeMatrixInt() {
-  exposeType<int>();
-  exposeType<int, Eigen::RowMajor>();
+void exposeMatrixInt8() {
+  exposeType<int8_t>();
+  exposeType<int8_t, Eigen::RowMajor>();
 }
 }  // namespace eigenpy

src/matrix-linux-long-long.cpp

+/*
+ * Copyright 2024 INRIA
+ */
+
+#include "eigenpy/eigenpy.hpp"
+
+namespace eigenpy {
+void exposeMatrixLinuxLongLong() {
+// On Linux, long long is a 64 bytes type but it's a different type than int64_t
+#ifdef __linux__
+  exposeType<long long>();
+  exposeType<long long, Eigen::RowMajor>();
+#endif  // linux
+}
+}  // namespace eigenpy