Renesas GR-PEACH OpenCV Development / gr-peach-opencv-project-sd-card_update

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Fork of gr-peach-opencv-project-sd-card by the do

Embed: (wiki syntax)

« Back to documentation index

SVD Class Reference
Public Types | Public Member Functions | Static Public Member Functions

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:
MODIFY_A 

allow the algorithm to modify the decomposed matrix; it can save space and speed up processing.

currently ignored.

NO_UV 

indicates that only a vector of singular values `w` is to be processed, while u and vt will be set to empty matrices

FULL_UV 

when the matrix is not square, by default the algorithm produces u and vt matrices of sufficiently large size for the further A reconstruction; if, however, FULL_UV flag is specified, u and vt will be full-size square orthogonal matrices.

Definition at line 2507 of file core.hpp.

Constructor & Destructor Documentation

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:
srcdecomposed matrix.
flagsoperation flags (SVD::Flags)

Member Function Documentation

void backSubst ( InputArray  w,
InputArray  u,
InputArray  vt,
InputArray  rhs,
OutputArray  dst 
) [static]

performs back substitution

Definition at line 1444 of file lapack.cpp.

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:

\[\texttt{x} = \texttt{vt} ^T \cdot diag( \texttt{w} )^{-1} \cdot \texttt{u} ^T \cdot \texttt{rhs} \sim \texttt{A} ^{-1} \cdot \texttt{rhs}\]

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:
rhsright-hand side of a linear system (u\*w\*v')\*dst = rhs to be solved, where A has been previously decomposed.
dstfound 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.

Definition at line 1479 of file lapack.cpp.

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 ( const Matx< _Tp, m, n > &  a,
Matx< _Tp, nm, 1 > &  w 
) [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:
srcdecomposed matrix
wcalculated singular values
ucalculated left singular vectors
vttransposed matrix of right singular values
flagsoperation flags - see SVD::SVD.

Definition at line 1434 of file lapack.cpp.

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:
srcdecomposed matrix
wcalculated singular values
flagsoperation flags - see SVD::Flags.

Definition at line 1439 of file lapack.cpp.

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:
srcdecomposed matrix.
flagsoperation flags (SVD::Flags)

Definition at line 1472 of file lapack.cpp.

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:

\[dst = \arg \min _{x: \| x \| =1} \| src \cdot x \|\]

Parameters:
srcleft-hand-side matrix.
dstfound solution.
Generated on Tue Jul 12 2022 14:48:01 by  doxygen 1.7.2