.. _program_listing_file_include_eigenpy_decompositions_ColPivHouseholderQR.hpp: Program Listing for File ColPivHouseholderQR.hpp ================================================ |exhale_lsh| :ref:`Return to documentation for file ` (``include/eigenpy/decompositions/ColPivHouseholderQR.hpp``) .. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS .. code-block:: cpp /* * Copyright 2024 INRIA */ #ifndef __eigenpy_decompositions_col_piv_houselholder_qr_hpp__ #define __eigenpy_decompositions_col_piv_houselholder_qr_hpp__ #include "eigenpy/eigenpy.hpp" #include "eigenpy/utils/scalar-name.hpp" #include namespace eigenpy { template struct ColPivHouseholderQRSolverVisitor : public boost::python::def_visitor< ColPivHouseholderQRSolverVisitor<_MatrixType> > { typedef _MatrixType MatrixType; typedef typename MatrixType::Scalar Scalar; typedef typename MatrixType::RealScalar RealScalar; typedef Eigen::Matrix VectorXs; typedef Eigen::Matrix MatrixXs; typedef Eigen::ColPivHouseholderQR Solver; typedef Solver Self; template void visit(PyClass &cl) const { cl.def(bp::init<>(bp::arg("self"), "Default constructor.\n" "The default constructor is useful in cases in which the " "user intends to perform decompositions via " "HouseholderQR.compute(matrix)")) .def(bp::init( bp::args("self", "rows", "cols"), "Default constructor with memory preallocation.\n" "Like the default constructor but with preallocation of the " "internal data according to the specified problem size. ")) .def(bp::init( bp::args("self", "matrix"), "Constructs a QR factorization from a given matrix.\n" "This constructor computes the QR factorization of the matrix " "matrix by calling the method compute().")) .def("absDeterminant", &Self::absDeterminant, bp::arg("self"), "Returns the absolute value of the determinant of the matrix of " "which *this is the QR decomposition.\n" "It has only linear complexity (that is, O(n) where n is the " "dimension of the square matrix) as the QR decomposition has " "already been computed.\n" "Note: This is only for square matrices.") .def("logAbsDeterminant", &Self::logAbsDeterminant, bp::arg("self"), "Returns the natural log of the absolute value of the determinant " "of the matrix of which *this is the QR decomposition.\n" "It has only linear complexity (that is, O(n) where n is the " "dimension of the square matrix) as the QR decomposition has " "already been computed.\n" "Note: This is only for square matrices. This method is useful to " "work around the risk of overflow/underflow that's inherent to " "determinant computation.") .def("dimensionOfKernel", &Self::dimensionOfKernel, bp::arg("self"), "Returns the dimension of the kernel of the matrix of which *this " "is the QR decomposition.") .def("info", &Self::info, bp::arg("self"), "Reports whether the QR factorization was successful.\n" "Note: This function always returns Success. It is provided for " "compatibility with other factorization routines.") .def("isInjective", &Self::isInjective, bp::arg("self"), "Returns true if the matrix associated with this QR decomposition " "represents an injective linear map, i.e. has trivial kernel; " "false otherwise.\n" "\n" "Note: This method has to determine which pivots should be " "considered nonzero. For that, it uses the threshold value that " "you can control by calling setThreshold(threshold).") .def("isInvertible", &Self::isInvertible, bp::arg("self"), "Returns true if the matrix associated with the QR decomposition " "is invertible.\n" "\n" "Note: This method has to determine which pivots should be " "considered nonzero. For that, it uses the threshold value that " "you can control by calling setThreshold(threshold).") .def("isSurjective", &Self::isSurjective, bp::arg("self"), "Returns true if the matrix associated with this QR decomposition " "represents a surjective linear map; false otherwise.\n" "\n" "Note: This method has to determine which pivots should be " "considered nonzero. For that, it uses the threshold value that " "you can control by calling setThreshold(threshold).") .def("maxPivot", &Self::maxPivot, bp::arg("self"), "Returns the absolute value of the biggest pivot, i.e. the " "biggest diagonal coefficient of U.") .def("nonzeroPivots", &Self::nonzeroPivots, bp::arg("self"), "Returns the number of nonzero pivots in the QR decomposition. " "Here nonzero is meant in the exact sense, not in a fuzzy sense. " "So that notion isn't really intrinsically interesting, but it is " "still useful when implementing algorithms.") .def("rank", &Self::rank, bp::arg("self"), "Returns the rank of the matrix associated with the QR " "decomposition.\n" "\n" "Note: This method has to determine which pivots should be " "considered nonzero. For that, it uses the threshold value that " "you can control by calling setThreshold(threshold).") .def("setThreshold", (Self & (Self::*)(const RealScalar &)) & Self::setThreshold, bp::args("self", "threshold"), "Allows to prescribe a threshold to be used by certain methods, " "such as rank(), who need to determine when pivots are to be " "considered nonzero. This is not used for the QR decomposition " "itself.\n" "\n" "When it needs to get the threshold value, Eigen calls " "threshold(). By default, this uses a formula to automatically " "determine a reasonable threshold. Once you have called the " "present method setThreshold(const RealScalar&), your value is " "used instead.\n" "\n" "Note: A pivot will be considered nonzero if its absolute value " "is strictly greater than |pivot| ⩽ threshold×|maxpivot| where " "maxpivot is the biggest pivot.", bp::return_self<>()) .def("threshold", &Self::threshold, bp::arg("self"), "Returns the threshold that will be used by certain methods such " "as rank().") .def("matrixQR", &Self::matrixQR, bp::arg("self"), "Returns the matrix where the Householder QR decomposition is " "stored in a LAPACK-compatible way.", bp::return_value_policy()) .def("matrixR", &Self::matrixR, bp::arg("self"), "Returns the matrix where the result Householder QR is stored.", bp::return_value_policy()) .def( "compute", (Solver & (Solver::*)(const Eigen::EigenBase &matrix)) & Solver::compute, bp::args("self", "matrix"), "Computes the QR factorization of given matrix.", bp::return_self<>()) .def("inverse", inverse, bp::arg("self"), "Returns the inverse of the matrix associated with the QR " "decomposition..") .def("solve", &solve, 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."); } static void expose() { static const std::string classname = "ColPivHouseholderQR" + scalar_name::shortname(); expose(classname); } static void expose(const std::string &name) { bp::class_( name.c_str(), "This class performs a rank-revealing QR decomposition of a matrix A " "into matrices P, Q and R such that:\n" "AP=QR\n" "by using Householder transformations. Here, P is a permutation " "matrix, Q a unitary matrix and R an upper triangular matrix.\n" "\n" "This decomposition performs column pivoting in order to be " "rank-revealing and improve numerical stability. It is slower than " "HouseholderQR, and faster than FullPivHouseholderQR.", bp::no_init) .def(ColPivHouseholderQRSolverVisitor()) .def(IdVisitor()); } private: template static MatrixOrVector solve(const Solver &self, const MatrixOrVector &vec) { return self.solve(vec); } static MatrixXs inverse(const Self &self) { return self.inverse(); } }; } // namespace eigenpy #endif // ifndef __eigenpy_decompositions_col_piv_houselholder_qr_hpp__