accelerate.hpp

Go to the documentation of this file.

/*
 * Copyright 2024 INRIA
 */
 
#ifndef __eigenpy_decomposition_sparse_accelerate_accelerate_hpp__
#define __eigenpy_decomposition_sparse_accelerate_accelerate_hpp__
 
#include "eigenpy/eigenpy.hpp"
#include "eigenpy/eigen/EigenBase.hpp"
#include "eigenpy/decompositions/sparse/SparseSolverBase.hpp"
 
#include <Eigen/AccelerateSupport>
 
namespace eigenpy {
 
template <typename AccelerateDerived>
struct AccelerateImplVisitor : public boost::python::def_visitor<
                                   AccelerateImplVisitor<AccelerateDerived> > {
  typedef AccelerateDerived Solver;
 
  typedef typename AccelerateDerived::MatrixType MatrixType;
  typedef typename MatrixType::Scalar Scalar;
  typedef typename MatrixType::RealScalar RealScalar;
  typedef MatrixType CholMatrixType;
  typedef typename MatrixType::StorageIndex StorageIndex;
 
  template <class PyClass>
  void visit(PyClass &cl) const {
    cl
 
        .def("analyzePattern", &Solver::analyzePattern,
             bp::args("self", "matrix"),
             "Performs a symbolic decomposition on the sparcity of matrix.\n"
             "This function is particularly useful when solving for several "
             "problems having the same structure.")
 
        .def(EigenBaseVisitor<Solver>())
        .def(SparseSolverBaseVisitor<Solver>())
 
        .def("compute",
             (Solver & (Solver::*)(const MatrixType &matrix)) & Solver::compute,
             bp::args("self", "matrix"),
             "Computes the sparse Cholesky decomposition of a given matrix.",
             bp::return_self<>())
 
        .def("factorize", &Solver::factorize, bp::args("self", "matrix"),
             "Performs a numeric decomposition of a given matrix.\n"
             "The given matrix must has the same sparcity than the matrix on "
             "which the symbolic decomposition has been performed.\n"
             "See also analyzePattern().")
 
        .def("info", &Solver::info, bp::arg("self"),
             "NumericalIssue if the input contains INF or NaN values or "
             "overflow occured. Returns Success otherwise.")
 
        .def("setOrder", &Solver::setOrder, bp::arg("self"), "Set order");
  }
 
  static void expose(const std::string &name, const std::string &doc = "") {
    bp::class_<Solver, boost::noncopyable>(name.c_str(), doc.c_str(),
                                           bp::no_init)
        .def(AccelerateImplVisitor())
 
        .def(bp::init<>(bp::arg("self"), "Default constructor"))
        .def(bp::init<MatrixType>(bp::args("self", "matrix"),
                                  "Constructs and performs the "
                                  "factorization from a given matrix."));
  }
};
 
}  // namespace eigenpy
 
#endif  // ifndef __eigenpy_decomposition_sparse_accelerate_accelerate_hpp__