opencv on mbed
SVD Class Reference
[Operations on arrays]
Singular Value Decomposition. More...
#include <core.hpp>
Public Types | |
enum | Flags { MODIFY_A = 1, NO_UV = 2, FULL_UV = 4 } |
Public Member Functions | |
SVD () | |
the default constructor | |
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() | |
SVD & | operator() (InputArray src, int flags=0) |
the operator that performs SVD. | |
void | backSubst (InputArray rhs, OutputArray dst) const |
performs a singular value back substitution. | |
Static Public Member Functions | |
static void | compute (InputArray src, OutputArray w, OutputArray u, OutputArray vt, int flags=0) |
decomposes matrix and stores the results to user-provided matrices | |
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. | |
static void | backSubst (InputArray w, InputArray u, InputArray vt, InputArray rhs, OutputArray dst) |
performs back substitution | |
static void | solveZ (InputArray src, OutputArray dst) |
solves an under-determined singular linear system | |
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) |
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) |
Detailed Description
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=SVDNO_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
Definition at line 2504 of file core.hpp.
Member Enumeration Documentation
enum Flags |
- Enumerator:
Constructor & Destructor Documentation
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)
Member Function Documentation
static void backSubst | ( | InputArray | w, |
InputArray | u, | ||
InputArray | vt, | ||
InputArray | rhs, | ||
OutputArray | dst | ||
) | [static] |
performs back substitution
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 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.
- 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.
- Note:
- 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.
static void compute | ( | const Matx< _Tp, m, n > & | a, |
Matx< _Tp, nm, 1 > & | w, | ||
Matx< _Tp, m, nm > & | u, | ||
Matx< _Tp, n, nm > & | vt | ||
) | [static] |
static void compute | ( | InputArray | src, |
OutputArray | w, | ||
OutputArray | u, | ||
OutputArray | vt, | ||
int | flags = 0 |
||
) | [static] |
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:
{.cpp} 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 |
||
) | [static] |
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.
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 solveZ | ( | InputArray | src, |
OutputArray | dst | ||
) | [static] |
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.
Generated on Tue Jul 12 2022 16:42:43 by 1.7.2