class cv::SVD
Overview
Singular Value Decomposition. More…
#include <core.hpp> class SVD { public: // enums enum Flags; // fields Mat u; Mat vt; Mat w; // construction SVD(); SVD( InputArray src, int flags = 0 ); // methods void backSubst( InputArray rhs, OutputArray dst ) const; SVD& operator()( InputArray src, int flags = 0 ); static void backSubst( InputArray w, InputArray u, InputArray vt, InputArray rhs, OutputArray dst ); template < typename _Tp, int m, int n, int nm, int nb > static void backSubst( const Matx<_Tp, nm, 1>& w, const Matx<_Tp, m, nm>& u, const Matx<_Tp, n, nm>& vt, const Matx<_Tp, m, nb>& rhs, Matx<_Tp, n, nb>& dst ); static void compute( InputArray src, OutputArray w, OutputArray u, OutputArray vt, int flags = 0 ); static void compute( InputArray src, OutputArray w, int flags = 0 ); template < typename _Tp, int m, int n, int nm > static void compute( const Matx<_Tp, m, n>& a, Matx<_Tp, nm, 1>& w, Matx<_Tp, m, nm>& u, Matx<_Tp, n, nm>& vt ); template < typename _Tp, int m, int n, int nm > static void compute( const Matx<_Tp, m, n>& a, Matx<_Tp, nm, 1>& w ); static void solveZ( InputArray src, OutputArray dst ); };
Detailed Documentation
Singular Value Decomposition.
Class for computing Singular Value Decomposition of a floating-point matrix. The Singular Value Decomposition is used to solve least-square problems, under-determined linear systems, invert matrices, compute condition numbers, and so on.
If you want to compute a condition number of a matrix or an absolute value of its determinant, you do not need u and vt. You can pass flags= SVD::NO_UV |… . Another flag SVD::FULL_UV indicates that full-size u and vt must be computed, which is not necessary most of the time.
See also:
invert, solve, eigen, determinant
Construction
SVD()
the default constructor
initializes an empty SVD structure
SVD( InputArray src, int flags = 0 )
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. initializes an empty SVD structure and then calls SVD::operator()
Parameters:
| src | decomposed matrix. |
| flags | operation flags (SVD::Flags) |
Methods
void backSubst( InputArray rhs, OutputArray dst ) const
performs a singular value back substitution.
The method calculates a back substitution for the specified right-hand side:
Using this technique you can either get a very accurate solution of the convenient linear system, or the best (in the least-squares terms) pseudo-solution of an overdetermined linear system.
Explicit SVD with the further back substitution only makes sense if you need to solve many linear systems with the same left-hand side (for example, src ). If all you need is to solve a single system (possibly with multiple rhs immediately available), simply call solve add pass DECOMP_SVD there. It does absolutely the same thing.
Parameters:
| rhs | right-hand side of a linear system (u*w*v’)*dst = rhs to be solved, where A has been previously decomposed. |
| dst | found solution of the system. |
SVD& operator()( InputArray src, int flags = 0 )
the operator that performs SVD. The previously allocated u, w and vt are released.
The operator performs the singular value decomposition of the supplied matrix. The u, vt, and the vector of singular values w are stored in the structure. The same SVD structure can be reused many times with different matrices. Each time, if needed, the previous u, vt, and w are reclaimed and the new matrices are created, which is all handled by Mat::create.
Parameters:
| src | decomposed matrix. |
| flags | operation flags (SVD::Flags) |
static void backSubst( InputArray w, InputArray u, InputArray vt, InputArray rhs, OutputArray dst )
performs back substitution
template < typename _Tp, int m, int n, int nm, int nb > static void backSubst( const Matx<_Tp, nm, 1>& w, const Matx<_Tp, m, nm>& u, const Matx<_Tp, n, nm>& vt, const Matx<_Tp, m, nb>& rhs, Matx<_Tp, n, nb>& dst )
Todo document
static void compute( InputArray src, OutputArray w, OutputArray u, OutputArray vt, int flags = 0 )
decomposes matrix and stores the results to user-provided matrices
The methods/functions perform SVD of matrix. Unlike SVD::SVD constructor and SVD::operator(), they store the results to the user-provided matrices:
Mat A, w, u, vt; SVD::compute(A, w, u, vt);
Parameters:
| src | decomposed matrix |
| w | calculated singular values |
| u | calculated left singular vectors |
| vt | transposed matrix of right singular values |
| flags | operation flags - see SVD::SVD. |
static void compute( InputArray src, OutputArray w, int flags = 0 )
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. computes singular values of a matrix
Parameters:
| src | decomposed matrix |
| w | calculated singular values |
| flags | operation flags - see SVD::Flags. |
template < typename _Tp, int m, int n, int nm > static void compute( const Matx<_Tp, m, n>& a, Matx<_Tp, nm, 1>& w, Matx<_Tp, m, nm>& u, Matx<_Tp, n, nm>& vt )
Todo document
template < typename _Tp, int m, int n, int nm > static void compute( const Matx<_Tp, m, n>& a, Matx<_Tp, nm, 1>& w )
Todo document
static void solveZ( InputArray src, OutputArray dst )
solves an under-determined singular linear system
The method finds a unit-length solution x of a singular linear system A*x = 0. Depending on the rank of A, there can be no solutions, a single solution or an infinite number of solutions. In general, the algorithm solves the following problem:
Parameters:
| src | left-hand-side matrix. |
| dst | found solution. |