CholmodSupernodalLLT.hpp

Go to the documentation of this file.

/*
 * Copyright 2024 INRIA
 */
 
#ifndef __eigenpy_decomposition_sparse_cholmod_cholmod_supernodal_llt_hpp__
#define __eigenpy_decomposition_sparse_cholmod_cholmod_supernodal_llt_hpp__
 
#include "eigenpy/eigenpy.hpp"
#include "eigenpy/decompositions/sparse/cholmod/CholmodDecomposition.hpp"
#include "eigenpy/utils/scalar-name.hpp"
 
namespace eigenpy {
 
template <typename MatrixType_, int UpLo_ = Eigen::Lower>
struct CholmodSupernodalLLTVisitor
    : public boost::python::def_visitor<
          CholmodSupernodalLLTVisitor<MatrixType_, UpLo_> > {
  typedef MatrixType_ MatrixType;
  typedef typename MatrixType::Scalar Scalar;
  typedef typename MatrixType::RealScalar RealScalar;
 
  typedef Eigen::CholmodSupernodalLLT<MatrixType_, UpLo_> Solver;
 
  template <class PyClass>
  void visit(PyClass &cl) const {
    cl
 
        .def(CholmodBaseVisitor<Solver>())
        .def(bp::init<>(bp::arg("self"), "Default constructor"))
        .def(bp::init<MatrixType>(bp::args("self", "matrix"),
                                  "Constructs and performs the LLT "
                                  "factorization from a given matrix."))
 
        ;
  }
 
  static void expose() {
    static const std::string classname =
        "CholmodSupernodalLLT_" + scalar_name<Scalar>::shortname();
    expose(classname);
  }
 
  static void expose(const std::string &name) {
    bp::class_<Solver, boost::noncopyable>(
        name.c_str(),
        "A supernodal direct Cholesky (LLT) factorization and solver based on "
        "Cholmod.\n\n"
        "This class allows to solve for A.X = B sparse linear problems via a "
        "supernodal LL^T Cholesky factorization using the Cholmod library."
        "This supernodal variant performs best on dense enough problems, e.g., "
        "3D FEM, or very high order 2D FEM."
        "The sparse matrix A must be selfadjoint and positive definite. The "
        "vectors or matrices X and B can be either dense or sparse.",
        bp::no_init)
        .def(CholmodSupernodalLLTVisitor());
  }
};
 
}  // namespace eigenpy
 
#endif  // ifndef
        // __eigenpy_decomposition_sparse_cholmod_cholmod_supernodal_llt_hpp__