STK::lapack::Svd Class Reference

{ More...

#include <STK_lapack_Svd.h>

Inheritance diagram for STK::lapack::Svd:

Public Types
typedef ISvd< Svd >	Base
typedef hidden::Traits< CArrayXX >::Col	ColVector
typedef hidden::Traits< CArrayXX >::Row	RowVector

Public Member Functions
	Svd (CArrayXX const &A, bool ref=false, bool withU=true, bool withV=true)
	Default constructor.
template<class OtherArray >
	Svd (ArrayBase< OtherArray > const &A, bool withU=true, bool withV=true)
	constructor with other kind of array/expression
	Svd (Svd const &decomp)
	Copy constructor.
virtual	~Svd ()
	virtual destructor
virtual Svd *	clone () const
	clone pattern
Svd &	operator= (Svd const &decomp)
	Operator = : overwrite the Svd with decomp.
char	jobz () const
void	setJobz (char jobz)
	set the option chosen for the svd
bool	runImpl ()
	Run svd decomposition.
Public Member Functions inherited from STK::ISvd< Svd >
Type	det () const
Type	trace () const
Type	norm () const
int	rank () const
ArrayU const &	U () const
ArrayV const &	V () const
ArrayD const &	D () const
virtual bool	run ()
	implement the run method
void	setData (OtherArray const &A, bool withU=true, bool withV=true)
	Set a new data set to ISvd class.
OtherArray &	ginv (OtherArray &res) const
	Compute the generalized inverse of the matrix and put the result in res.
Public Member Functions inherited from STK::IRunnerBase
String const &	error () const
	get the last error message.
Public Member Functions inherited from STK::IRecursiveTemplate< Derived >
Derived &	asDerived ()
	static cast : return a reference of this with a cast to the derived class.
Derived const &	asDerived () const
	static cast : return a const reference of this with a cast to the derived class.
Derived *	asPtrDerived ()
	static cast : return a ptr on a Derived of this with a cast to the derived class.
Derived const *	asPtrDerived () const
	static cast : return a ptr on a constant Derived of this with a cast to the derived class.
Derived *	clone () const
	create a leaf using the copy constructor of the Derived class.
Derived *	clone (bool isRef) const
	create a leaf using the copy constructor of the Derived class and a flag determining if the clone is a reference or not.

Private Member Functions
bool	computeSvd (CArrayXX &a, CArrayXX &u, CVectorX &s, CArrayXX &v)
	compute the svd decomposition.

Private Attributes
char	jobz_
	option

Additional Inherited Members
Protected Types inherited from STK::ISvd< Svd >
typedef hidden::AlgebraTraits< Svd >::ArrayU	ArrayU
typedef hidden::AlgebraTraits< Svd >::ArrayD	ArrayD
typedef hidden::AlgebraTraits< Svd >::ArrayV	ArrayV
typedef ArrayU::Type	Type
Protected Member Functions inherited from STK::ISvd< Svd >
	ISvd (ArrayU const &A, bool ref, bool withU=true, bool withV=true)
	Default constructor.
	ISvd (ArrayBase< OtherDerived > const &A, bool withU=true, bool withV=true)
	constructor with other kind of array/expression
	ISvd (ISvd const &S)
	Copy Constructor.
virtual	~ISvd ()
	destructor.
ISvd &	operator= (const ISvd &S)
	Operator = : overwrite the ISvd with S.
virtual void	finalize ()
	Finalize any operations that have to be done after the computation of the decomposition.
int	nrowU () const
int	ncolU () const
int	nrowD () const
int	ncolD () const
int	nrowV () const
int	ncolV () const
Protected Member Functions inherited from STK::IRunnerBase
	IRunnerBase ()
	default constructor
	IRunnerBase (IRunnerBase const &runner)
	copy constructor
virtual	~IRunnerBase ()
	destructor
virtual void	update ()
	update the runner.
Protected Member Functions inherited from STK::IRecursiveTemplate< Derived >
	IRecursiveTemplate ()
	constructor.
	~IRecursiveTemplate ()
	destructor.
Protected Attributes inherited from STK::ISvd< Svd >
ArrayU	U_
	U_ matrix.
ArrayV	V_
	V_ matrix.
ArrayD	D_
	Diagonal array of the singular values.
bool	withU_
	Compute U_ ?
bool	withV_
	Compute V_ ?
Type	norm_
	trace norm
int	rank_
	rank
Type	trace_
	trace norm
Type	det_
	determinant
Protected Attributes inherited from STK::IRunnerBase
String	msg_error_
	String with the last error message.
bool	hasRun_
	true if run has been used, false otherwise

Detailed Description

{

Svd computes the SVD decomposition of a real matrix using the Lapack routine dgeqrf.

The method take as:

• input: a matrix A(nrow,ncol)
• output:
  1. U Array (nrow,ncol).
  2. D diagonal matrix (min(norw,ncol))
  3. V Array (ncol,ncol). and perform the decomposition:

• A = UDV' (transpose V).

  Output can be tuned using jobz option:

  *      jobz is Char*1
  *      Specifies options for computing all or part of the matrix u:
  *      = 'A':  all m columns of u and all n rows of v**T are
  *              returned in the arrays u and vt;
  *      = 'S':  the first min(m,n) columns of u and the first
  *              min(m,n) rows of v**T are returned in the arrays U
  *              and vt;
  *      = 'O':  If m >= n, the first n columns of u are overwritten
  *              on the array a and all rows of v**T are returned in
  *              the array vt;
  *              otherwise, all columns of u are returned in the
  *              array u and the first m rows of v**T are overwritten
  *              in the array a;
  *      = 'N':  no columns of u or rows of v**T are computed.
  *   

See also

SK::ISvd, STK::Svd

Definition at line 107 of file STK_lapack_Svd.h.

Member Typedef Documentation

Base

typedef ISvd< Svd > STK::lapack::Svd::Base

Definition at line 110 of file STK_lapack_Svd.h.

ColVector

typedef hidden::Traits<CArrayXX>::Col STK::lapack::Svd::ColVector

Definition at line 111 of file STK_lapack_Svd.h.

RowVector

typedef hidden::Traits<CArrayXX>::Row STK::lapack::Svd::RowVector

Definition at line 112 of file STK_lapack_Svd.h.

Constructor & Destructor Documentation

Svd() [1/3]

STK::lapack::Svd::Svd ( CArrayXX const &  A, bool  ref = false, bool  withU = true, bool  withV = true  )

inline

Default constructor.

Parameters

A	matrix to decompose
ref	if true, U_ is a reference of A.
withU	if true save the left Householder transforms in U_.
withV	if true save the right Householder transforms in V_.

Definition at line 131 of file STK_lapack_Svd.h.

              : Base(A, ref, withU, withV), jobz_( (withU|withV) ? 'O':'N') {}

Svd() [2/3]

template<class OtherArray >

STK::lapack::Svd::Svd ( ArrayBase< OtherArray > const &  A, bool  withU = true, bool  withV = true  )

inline

constructor with other kind of array/expression

Parameters

A	the matrix/expression to decompose.
withU	if true save the left Householder transforms in U_.
withV	if true save the right Householder transforms in V_.

Definition at line 139 of file STK_lapack_Svd.h.

              : Base(A, withU, withV), jobz_( (withU|withV) ? 'O':'N') {}

Svd() [3/3]

STK::lapack::Svd::Svd ( Svd const &  decomp )

inline

Copy constructor.

Parameters

decomp

the decomposition to copy

Definition at line 144 of file STK_lapack_Svd.h.

: Base(decomp), jobz_(decomp.jobz_) {}

~Svd()

virtual STK::lapack::Svd::~Svd ( )

inlinevirtual

virtual destructor

Definition at line 146 of file STK_lapack_Svd.h.

{}

Member Function Documentation

clone()

virtual Svd * STK::lapack::Svd::clone ( ) const

inlinevirtual

clone pattern

Definition at line 148 of file STK_lapack_Svd.h.

{ return new Svd(*this);}

computeSvd()

bool STK::lapack::Svd::computeSvd ( CArrayXX &  a, CArrayXX &  u, CVectorX &  s, CArrayXX &  v  )

inlineprivate

compute the svd decomposition.

a contains either u, vt (if jobz_=='O') or is destroyed at the end of the oputput.

Definition at line 202 of file STK_lapack_Svd.h.

{
  int m = a.sizeRows(), n = a.sizeCols(), nbSv = std::min(m,n);
  a.shift(0,0);
  // Workspace and status variables:
  double workSize;
  double *p_work = &workSize;
  int* p_iwork = new int[8*nbSv];
  int lwork = -1;
  int info;
  //
  // Call dgesdd_ with lwork = -1 to query optimal workspace size:
  info = gesdd( jobz_, m, n
               , a.p_data(), m, s.p_data(), u.p_data(), m, vt.p_data(), n
               , p_work, lwork, p_iwork);
  // check any error
  if (info!=0)
  {
    if (info>0)
    { this->msg_error_ = STKERROR_NO_ARG(lapack::Svd::computeSvd,internal error);
      return false;
    }
    this->msg_error_= STKERROR_1ARG(lapack::Svd::computeSvd get,-info,error parameter);
    return false;
  }
  // optimal storage dimension is returned in work[0]
  lwork = workSize;
  p_work = new Real[lwork];
  // resize u
  if ( !((jobz_ == 'O' && m >= n) || (jobz_ == 'N')) )
  {
    int ucol = (jobz_ == 'A' || jobz_ == 'O') ? m : nbSv;
    u.resize(m, ucol);
  }
  if ( !((jobz_ == 'O' && m < n)  || (jobz_ == 'N')) )
  {
    int ldvt = (jobz_ == 'A' || jobz_ == 'O') ? n : nbSv;
    vt.resize(ldvt,n);
  }
  s.resize(nbSv).shift(0);
  u.shift(0,0);
  vt.shift(0,0);
 
  // Call dgesdd_ to do the actual computation:
  info = gesdd( jobz_, m, n
              , a.p_data(), a.sizeRows(), s.p_data()
              , u.p_data(), u.sizeRows()
              , vt.p_data(), vt.sizeRows()
              , p_work, lwork, p_iwork);
  // clean
  delete[] p_work;
  delete[] p_iwork;
  // check any error
  if (info!=0)
  {
    if (info>0)
    { this->msg_error_ = STKERROR_NO_ARG(lapack::Svd::computeSvd,internal error);
      return false;
    }
    this->msg_error_= STKERROR_1ARG(lapack::Svd::computeSvd get,-info,error parameter);
    return false;
  }
  return true;
}

References computeSvd(), STK::IRunnerBase::error(), STK::lapack::gesdd(), jobz_, STK::IRunnerBase::msg_error_, STK::ICArray< Derived >::p_data(), STK::ICArray< Derived >::resize(), STK::ICArray< Derived >::shift(), STKERROR_1ARG, and STKERROR_NO_ARG.

Referenced by computeSvd(), and runImpl().

jobz()

char STK::lapack::Svd::jobz ( ) const

inline

Returns

the option chosen for the svd

Definition at line 158 of file STK_lapack_Svd.h.

{ return jobz_;}

References jobz_.

Referenced by setJobz().

operator=()

Svd & STK::lapack::Svd::operator= ( Svd const &  decomp )

inline

Operator = : overwrite the Svd with decomp.

Definition at line 150 of file STK_lapack_Svd.h.

    {
      Base::operator=(decomp);
      jobz_ = decomp.jobz_;
      return *this;
    }

References jobz_, and STK::ISvd< Svd >::operator=().

runImpl()

bool STK::lapack::Svd::runImpl ( )

inline

Run svd decomposition.

Definition at line 175 of file STK_lapack_Svd.h.

{
  if (jobz_ == 'A' || jobz_ == 'S')
  {
    msg_error_ = _T("In lapack::Svd::runImpl, the options 'A' and 'S' are not available");
    return false;
  }
  int beginRow = U_.beginRows(), beginCol = U_.beginCols();
  bool result = true;
  // compute results
  if ( (jobz_ == 'O' && U_.sizeRows() >= U_.sizeCols()) || jobz_ == 'N')
  {
    if (!computeSvd(U_, U_, D_, V_)) { result = false;}
  }
  else
  { // jobz_ == 'O' and m<n, V_ will contain u and U_ will contain vt
    if (!computeSvd(U_, V_, D_, V_)) { result = false;};
    U_.exchange(V_); // !now U_ is (m,m) and V_ is (m,n)
  }
  U_.shift(beginRow, beginCol);
  D_.shift(beginCol);
  transpose(V_.shift(beginCol));
  return result;
}

References _T, computeSvd(), STK::ISvd< Svd >::D_, jobz_, STK::IRunnerBase::msg_error_, STK::transpose(), STK::ISvd< Svd >::U_, and STK::ISvd< Svd >::V_.

setJobz()

void STK::lapack::Svd::setJobz ( char  jobz )

inline

set the option chosen for the svd

Definition at line 161 of file STK_lapack_Svd.h.

{ jobz_ = jobz;}

References jobz(), and jobz_.

Member Data Documentation

jobz_

char STK::lapack::Svd::jobz_

private

option

Definition at line 168 of file STK_lapack_Svd.h.

Referenced by computeSvd(), jobz(), operator=(), runImpl(), and setJobz().

---

The documentation for this class was generated from the following file:

• STK_lapack_Svd.h