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

@@ -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();
@@ -23,6 +36,7 @@ void exposeMatrixComplexDouble();
 void exposeMatrixComplexLongDouble();
 
 void exposeNoneType();
+void exposeTypeInfo();
 
 /* Enable Eigen-Numpy serialization for a set of standard MatrixBase instances.
  */
@@ -47,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();
@@ -58,6 +85,15 @@ void enableEigenPy() {
   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

src/matrix-linux-ulong-long.cpp

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

src/matrix-mac-long.cpp

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

src/matrix-mac-ulong.cpp

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

src/matrix-uint16.cpp

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

src/matrix-uint32.cpp

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