sparse: add SparseSolverBaseVisitor

Author: jcarpent

CMakeLists.txt

@@ -142,7 +142,8 @@ set(${PROJECT_NAME}_DECOMPOSITIONS_SPARSE_CHOLMOD_HEADERS
 set(${PROJECT_NAME}_DECOMPOSITIONS_SPARSE_HEADERS
     include/eigenpy/decompositions/sparse/LLT.hpp
     include/eigenpy/decompositions/sparse/LDLT.hpp
-    include/eigenpy/decompositions/sparse/SimplicialCholesky.hpp)
+    include/eigenpy/decompositions/sparse/SimplicialCholesky.hpp
+    include/eigenpy/decompositions/sparse/SparseSolverBase.hpp)
 
 if(BUILD_WITH_CHOLMOD_SUPPORT)
   list(APPEND ${PROJECT_NAME}_DECOMPOSITIONS_SPARSE_HEADERS

include/eigenpy/decompositions/sparse/SimplicialCholesky.hpp

@@ -7,6 +7,7 @@
 
 #include "eigenpy/eigenpy.hpp"
 #include "eigenpy/eigen/EigenBase.hpp"
+#include "eigenpy/decompositions/sparse/SparseSolverBase.hpp"
 
 #include <Eigen/SparseCholesky>
 
@@ -37,6 +38,7 @@ struct SimplicialCholeskyVisitor
            "problems having the same structure.")
 
         .def(EigenBaseVisitor<Solver>())
+        .def(SparseSolverBaseVisitor<Solver>())
 
         .def("matrixL", &matrixL, bp::arg("self"),
              "Returns the lower triangular matrix L.")
@@ -74,33 +76,17 @@ struct SimplicialCholeskyVisitor
              "scale=1.",
              bp::return_self<>())
 
-        .def("solve", &solve<DenseVectorXs>, bp::args("self", "b"),
-             "Returns the solution x of A x = b using the current "
-             "decomposition of A.")
-        .def("solve", &solve<DenseMatrixXs>, bp::args("self", "B"),
-             "Returns the solution X of A X = B using the current "
-             "decomposition of A where B is a right hand side matrix.")
-
         .def("permutationP", &Solver::permutationP, bp::arg("self"),
              "Returns the permutation P.",
              bp::return_value_policy<bp::copy_const_reference>())
         .def("permutationPinv", &Solver::permutationPinv, bp::arg("self"),
              "Returns the inverse P^-1 of the permutation P.",
-             bp::return_value_policy<bp::copy_const_reference>())
-
-        .def("solve", &solve<MatrixType>, bp::args("self", "B"),
-             "Returns the solution X of A X = B using the current "
-             "decomposition of A where B is a right hand side matrix.");
+             bp::return_value_policy<bp::copy_const_reference>());
   }
 
  private:
   static MatrixType matrixL(const Solver &self) { return self.matrixL(); }
   static MatrixType matrixU(const Solver &self) { return self.matrixU(); }
-
-  template <typename MatrixOrVector>
-  static MatrixOrVector solve(const Solver &self, const MatrixOrVector &vec) {
-    return self.solve(vec);
-  }
 };
 
 }  // namespace eigenpy

include/eigenpy/decompositions/sparse/SparseSolverBase.hpp

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2024 INRIA
+ */
+
+#ifndef __eigenpy_decomposition_sparse_sparse_solver_base_hpp__
+#define __eigenpy_decomposition_sparse_sparse_solver_base_hpp__
+
+#include "eigenpy/eigenpy.hpp"
+#include "eigenpy/eigen/EigenBase.hpp"
+
+#include <Eigen/SparseCholesky>
+
+namespace eigenpy {
+
+template <typename SimplicialDerived>
+struct SparseSolverBaseVisitor
+    : public boost::python::def_visitor<
+          SparseSolverBaseVisitor<SimplicialDerived> > {
+  typedef SimplicialDerived Solver;
+
+  typedef typename SimplicialDerived::MatrixType MatrixType;
+  typedef typename MatrixType::Scalar Scalar;
+  typedef typename MatrixType::RealScalar RealScalar;
+
+  typedef Eigen::Matrix<Scalar, Eigen::Dynamic, 1, MatrixType::Options>
+      DenseVectorXs;
+  typedef Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic,
+                        MatrixType::Options>
+      DenseMatrixXs;
+
+  template <class PyClass>
+  void visit(PyClass &cl) const {
+    cl.def("solve", &solve<DenseVectorXs>, bp::args("self", "b"),
+           "Returns the solution x of A x = b using the current "
+           "decomposition of A.")
+        .def("solve", &solve<DenseMatrixXs>, bp::args("self", "B"),
+             "Returns the solution X of A X = B using the current "
+             "decomposition of A where B is a right hand side matrix.")
+
+        .def("solve", &solve<MatrixType>, bp::args("self", "B"),
+             "Returns the solution X of A X = B using the current "
+             "decomposition of A where B is a right hand side matrix.");
+  }
+
+ private:
+  template <typename MatrixOrVector>
+  static MatrixOrVector solve(const Solver &self, const MatrixOrVector &vec) {
+    return self.solve(vec);
+  }
+};
+
+}  // namespace eigenpy
+
+#endif  // ifndef __eigenpy_decomposition_sparse_sparse_solver_base_hpp__

include/eigenpy/decompositions/sparse/cholmod/CholmodBase.hpp

@@ -7,6 +7,7 @@
 
 #include "eigenpy/eigenpy.hpp"
 #include "eigenpy/eigen/EigenBase.hpp"
+#include "eigenpy/decompositions/sparse/SparseSolverBase.hpp"
 
 #include <Eigen/CholmodSupport>
 
@@ -23,12 +24,6 @@ struct CholmodBaseVisitor
   typedef MatrixType CholMatrixType;
   typedef typename MatrixType::StorageIndex StorageIndex;
 
-  typedef Eigen::Matrix<Scalar, Eigen::Dynamic, 1, MatrixType::Options>
-      DenseVectorXs;
-  typedef Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic,
-                        MatrixType::Options>
-      DenseMatrixXs;
-
   template <class PyClass>
   void visit(PyClass &cl) const {
     cl.def("analyzePattern", &Solver::analyzePattern,
@@ -38,6 +33,7 @@ struct CholmodBaseVisitor
            "problems having the same structure.")
 
         .def(EigenBaseVisitor<Solver>())
+        .def(SparseSolverBaseVisitor<Solver>())
 
         .def("compute",
              (Solver & (Solver::*)(const MatrixType &matrix)) & Solver::compute,
@@ -70,24 +66,7 @@ struct CholmodBaseVisitor
              "are transformed by the following linear model: d_ii = offset + "
              "d_ii.\n"
              "The default is the identity transformation with offset=0.",
-             bp::return_self<>())
-
-        .def("solve", &solve<DenseVectorXs>, bp::args("self", "b"),
-             "Returns the solution x of A x = b using the current "
-             "decomposition of A.")
-        .def("solve", &solve<DenseMatrixXs>, bp::args("self", "B"),
-             "Returns the solution X of A X = B using the current "
-             "decomposition of A where B is a right hand side matrix.")
-
-        .def("solve", &solve<MatrixType>, bp::args("self", "B"),
-             "Returns the solution X of A X = B using the current "
-             "decomposition of A where B is a right hand side matrix.");
-  }
-
- private:
-  template <typename MatrixOrVector>
-  static MatrixOrVector solve(const Solver &self, const MatrixOrVector &vec) {
-    return self.solve(vec);
+             bp::return_self<>());
   }
 };