STK::IQr< Derived > Class Template Reference

The class IQr is an interface class for the method computing the QR Decomposition of a ArrayXX. More...

#include <STK_IQr.h>

Inheritance diagram for STK::IQr< Derived >:

Public Member Functions
virtual	~IQr ()
	virtual destructor
IQr &	operator= (IQr const &decomp)
	Operator = : overwrite the this with decomp.
bool	isCompQ () const
int	rank () const
Array const &	Q () const
	give the matrix Q of the QR decomposition.
ArrayUpperTriangularXX const &	R () const
	give the matrix R of the QR decomposition.
void	setCompQ (bool compq)
	Set the compq_ flag.
virtual bool	run ()
	Compute the QR decomposition.
void	compQ ()
	Compute Q (to use after run).
void	popBackCols (int n=1)
	Delete the n last columns and update the QR decomposition.
void	eraseCol (int pos)
	Delete the column pos and update the QR decomposition.
template<class ColVector_ >
void	pushBackCol (ColVector_ const &T)
	Add a column with value T and update th QR decomposition.
template<class ColVector_ >
void	insertCol (ColVector_ const &T, int pos)
	Add a column with value T at the position pos and update the QR decomposition.
template<class OtherDerived >
void	setData (ExprBase< OtherDerived > const &data)
	overloading of setData.
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.

Protected Types
typedef hidden::AlgebraTraits< Derived >::Array	Array
typedef hidden::AlgebraTraits< Derived >::ColVector	ColVector
typedef hidden::AlgebraTraits< Derived >::RowVector	RowVector

Protected Member Functions
	IQr (Array const &Q, bool ref=false)
	Constructor.
template<class DerivedExpr >
	IQr (ExprBase< DerivedExpr > const &Q)
	Constructor.
	IQr (IQr const &decomp)
	Copy constructor.
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
Array	Q_
	Q Array of the QR decomposition.
ArrayUpperTriangularXX	R_
	R Array of th QR decomposition.
bool	compq_
	is Q computed ?
int	rank_
	estimated rank_ of the matrix A
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

template<class Derived>
class STK::IQr< Derived >

The class IQr is an interface class for the method computing the QR Decomposition of a ArrayXX.

The QR decomposition of a matrix require

• Input: A matrix of size M-by-N
• Output:
  1. Q Array of size M-by-N.
  2. R Upper Triangular matrix of dimension min(M,N)-by-N
  3. 

Computation of matrices Q and R is triggered by the run() method. Some tuning parameters can be adjusted before running.

The matrix Q is represented as a product of elementary reflectors Q = H(1) H(2) . . . H(k), where k = min(m,n).

Each H(i) has the form H(i) = I - tau * v * v'

Note

This interface class implement the virtual run method of IRunnerBase by calling the derived method runImpl

Definition at line 101 of file STK_IQr.h.

Member Typedef Documentation

Array

template<class Derived >

typedef hidden::AlgebraTraits<Derived>::Array STK::IQr< Derived >::Array

protected

Definition at line 104 of file STK_IQr.h.

ColVector

template<class Derived >

typedef hidden::AlgebraTraits<Derived>::ColVector STK::IQr< Derived >::ColVector

protected

Definition at line 105 of file STK_IQr.h.

RowVector

template<class Derived >

typedef hidden::AlgebraTraits<Derived>::RowVector STK::IQr< Derived >::RowVector

protected

Definition at line 106 of file STK_IQr.h.

Constructor & Destructor Documentation

IQr() [1/3]

template<class Derived >

STK::IQr< Derived >::IQr ( Array const &  Q, bool  ref = false  )

inlineprotected

Constructor.

Parameters

Q	The matrix to decompose
ref	is Q_ a reference ? (avoid data copy, but the original data set is destroyed)

Definition at line 112 of file STK_IQr.h.

              : IRunnerBase(), Q_(Q, ref), compq_(false), rank_(0)
    {
      if (Q.beginRows() != Q.beginCols())
        STKRUNTIME_ERROR_NO_ARG(IQR::IQR,Wrong data set: Q.beginRows() must be equal to Q.beginCols());
    }

References STK::IQr< Derived >::Q(), and STKRUNTIME_ERROR_NO_ARG.

IQr() [2/3]

template<class Derived >

template<class DerivedExpr >

STK::IQr< Derived >::IQr ( ExprBase< DerivedExpr > const &  Q )

inlineprotected

Constructor.

Parameters

Q	The matrix to decompose

Definition at line 122 of file STK_IQr.h.

                                        : IRunnerBase(), compq_(false), rank_(0)
    {
      if (Q.beginRows() != Q.beginCols())
      { STKRUNTIME_ERROR_NO_ARG(IQR::IQR,Wrong data set: Q.beginRows() must be equal to Q.beginCols());}
      Q_ = Q.asDerived();
    }

References STK::IQr< Derived >::Q(), STK::IQr< Derived >::Q_, and STKRUNTIME_ERROR_NO_ARG.

IQr() [3/3]

template<class Derived >

STK::IQr< Derived >::IQr ( IQr< Derived > const &  decomp )

inlineprotected

Copy constructor.

Parameters

decomp

the decomposition to copy

Definition at line 131 of file STK_IQr.h.

              : Q_(decomp.Q_), R_(decomp.R_), compq_(decomp.compq_), rank_(decomp.rank_)
    {}

~IQr()

template<class Derived >

virtual STK::IQr< Derived >::~IQr ( )

inlinevirtual

virtual destructor

Definition at line 137 of file STK_IQr.h.

{}

Member Function Documentation

compQ()

template<class Derived >

void STK::IQr< Derived >::compQ

(

)

Compute Q (to use after run).

After the run process, Q_ store the householder vector in its column. Call compQ, if you want to obtain Q in its true form. Without effect if (compq_ == true)

Definition at line 245 of file STK_IQr.h.

{
#ifdef STK_ALGEBRA_VERBOSE
  stk_cout << _T("Entering IQr::compQ()") << _T("\n");
#endif
  // if Q_ is computed yet
  if (compq_) return;
  // number of non zero cols of Q_
  int ncol  = std::min(Q_.sizeRows(), Q_.sizeCols()), lastCol;
  // add or remove the column
  if (ncol < Q_.sizeCols())
  {
    Q_.popBackCols(Q_.sizeCols() - ncol);
    Q_.popBackCols(Q_.sizeCols() - ncol);
    lastCol = Q_.lastIdxCols();
  }
  else
  {
    lastCol = Q_.lastIdxCols();
    if (ncol < Q_.sizeRows())
    {
      Q_.pushBackCols(Q_.sizeRows() -ncol);
      // Initialize added columns
      Q_.col( _R( lastCol+1, Q_.lastIdxCols()) ).setValue(0);
      for (int i=lastCol+1; i< Q_.endCols(); ++i) { Q_(i, i) = 1.0;}
    }
  }
  // compute other columns
  for (int i=lastCol; i>=Q_.beginCols(); i--)
  {
    // create reference on current householder vector
    ColVector u(Q_, _R(i, Q_.lastIdxRows()), i);
    // Apply Householder vector to the right of the matrix
    applyLeftHouseholderVector( Q_( _R(i, Q_.lastIdxRows()), _R(i+1, Q_.lastIdxCols())), u);
    // update the ith column
    Q_( _R(Q_.beginRows(),i-1)   , i ) = 0.0;   //     0:(i-1)
    Q_( _R(i+1, Q_.lastIdxRows()), i ) *= Q_(i,i); // (i+1):M
    Q_( i                        , i ) += 1.0;  //     i:i
    // update the column i
  }
  // Q_ is now computed
  compq_ = true;
#ifdef  STK_ALGEBRA_VERBOSE
  stk_cout << _T("Terminating IQr::compQ().") << _T("\n");
#endif
}

References _R, _T, STK::applyLeftHouseholderVector(), and stk_cout.

eraseCol()

template<class Derived >

void STK::IQr< Derived >::eraseCol

(

int

pos

)

Delete the column pos and update the QR decomposition.

Parameters

pos	the position of the column to delete

Definition at line 298 of file STK_IQr.h.

{
  if (pos < R_.beginCols())
  { STKOUT_OF_RANGE_1ARG(Qr::eraseCol,pos,pos<R_.beginCols());}
  if (R_.lastIdxCols() < pos)
  { STKOUT_OF_RANGE_1ARG(Qr::eraseCol,pos,pos<R_.lastIdxCols()<pos);}
  // if Q_ is not computed yet
  if (!compq_) compQ();
  // compute the number of iteration for updating to zeroed
  int niter = std::min(R_.lastIdxCols(), R_.lastIdxRows());//R_.beginCols()-1+std::min(R_.sizeRows(), R_.sizeCols());
  // Zeroed the remaining elements (z)
  for (int iter = pos+1; iter<= niter; iter++)
  {
    Real sinus, cosinus;
    // compute the Givens rotation
    R_(iter-1, iter) = compGivens( R_(iter-1, iter), R_(iter, iter), cosinus, sinus);
    R_(iter, iter)   = 0.0;
    // if necessary update R_ and Q_
    if (sinus)
    {
      // create a reference on the sub-ArrayXX
      ArrayUpperTriangularXX Rsub(R_.col( _R(iter+1, R_.lastIdxCols()) ), true);
      // Update the next rows (iter1:ncolr_) of R_
      leftGivens(Rsub, iter-1, iter, cosinus, sinus);
      // Update the cols of Q_
      rightGivens(Q_, iter-1, iter, cosinus, sinus);
    }
  }
  // erase the column pos
  R_.eraseCols(pos);
  // update the range of the remaining cols of the container
  R_.update( Range(pos, std::min(R_.lastIdxRows(), R_.lastIdxCols()), 0));
}

References _R, STK::compGivens(), STK::IQr< Qr >::eraseCol(), STK::leftGivens(), STK::rightGivens(), and STKOUT_OF_RANGE_1ARG.

Referenced by main().

insertCol()

template<class Derived >

template<class ColVector_ >

void STK::IQr< Derived >::insertCol	(	ColVector_ const &	T,
		int	pos
	)

Add a column with value T at the position pos and update the QR decomposition.

Parameters

T	the column to insert
pos	the position of the column to insert

Definition at line 370 of file STK_IQr.h.

{
  STK_STATIC_ASSERT(ColVector_::structure_==(int)Arrays::vector_||ColVector_::structure_==(int)Arrays::point_,YOU_HAVE_TO_USE_A_VECTOR_OR_POINT_IN_THIS_METHOD)
  if (pos < R_.beginCols())
  { STKOUT_OF_RANGE_1ARG(Qr::insertCol,pos,pos<R_.beginCols());}
  if (R_.lastIdxCols() < pos)
  { STKOUT_OF_RANGE_1ARG(Qr::insertCol,pos,pos<R_.lastIdxCols()<pos);}
  if (T.range() != Q_.rows())
  { STKRUNTIME_ERROR_1ARG(Qr::insertCol,pos,T.range() != Q_.rows());}
  // if Q_ is not computed yet
  if (!compq_) compQ();
  // Adding a column to R
  R_.insertCols(pos);
  // update the range of the remaining cols of R_
  R_.update( _R(pos+1, std::min(R_.lastIdxRows(), R_.lastIdxCols())) );
  for (int i=pos+1; i< std::min(R_.endRows(), R_.endCols()); ++i) R_(i,i) = 0.0;
 
  VectorX Rpos =  Q_.transpose() * T;
  // Zeroed the unwanted elements
  for (int iter= Q_.lastIdxCols(), iterm1= Q_.lastIdxCols()-1; iter>pos; iterm1--, iter--)
  {
    Real sinus, cosinus;
    // compute the Givens rotation
    Rpos[iterm1]  = compGivens(Rpos[iterm1], Rpos[iter], cosinus, sinus);
    // apply Givens rotation if necessary
    if (sinus)
    {
      // create a reference on the sub-ArrayXX
      ArrayUpperTriangularXX Rsub(R_.col(_R(iter, R_.lastIdxCols())), true);
      // Update the next rows (iter:ncolr_) of R_
      leftGivens( Rsub, iterm1, iter, cosinus, sinus);
      // Update the cols of Q_
      rightGivens(Q_, iterm1, iter, cosinus, sinus);
    }
  }
  // update R_
  R_.col(pos) = Rpos.sub(R_.rangeRowsInCol(pos));
  R_.update(pos);
}

References _R, STK::compGivens(), STK::IQr< Qr >::insertCol(), STK::leftGivens(), STK::Arrays::point_, STK::rightGivens(), STK_STATIC_ASSERT, STKOUT_OF_RANGE_1ARG, STKRUNTIME_ERROR_1ARG, STK::IRunnerSupervised< YArray_, XArray_, Weights_ >::update(), and STK::Arrays::vector_.

Referenced by main().

isCompQ()

template<class Derived >

bool STK::IQr< Derived >::isCompQ ( ) const

inline

Returns

true if Q_ is computed, false otherwise

Definition at line 149 of file STK_IQr.h.

{ return compq_;}

References STK::IQr< Derived >::compq_.

operator=()

template<class Derived >

IQr & STK::IQr< Derived >::operator= ( IQr< Derived > const &  decomp )

inline

Operator = : overwrite the this with decomp.

Definition at line 139 of file STK_IQr.h.

    {
      Q_ = decomp.Q_;
      R_ = decomp.R_;
      compq_ = decomp.compq_;
      rank_ = decomp.rank_;
      return *this;
    }

References STK::IQr< Derived >::compq_, STK::IQr< Derived >::Q_, STK::IQr< Derived >::R_, and STK::IQr< Derived >::rank_.

popBackCols()

template<class Derived >

void STK::IQr< Derived >::popBackCols

(

int

n = 1

)

Delete the n last columns and update the QR decomposition.

Parameters

n	number of column to delete

Definition at line 293 of file STK_IQr.h.

{ R_.popBackCols(n);}

pushBackCol()

template<class Derived >

template<class ColVector_ >

void STK::IQr< Derived >::pushBackCol

(

ColVector_ const &

T

)

Add a column with value T and update th QR decomposition.

Parameters

T	the column to add

Definition at line 335 of file STK_IQr.h.

{
  STK_STATIC_ASSERT(ColVector_::structure_==(int)Arrays::vector_||ColVector_::structure_==(int)Arrays::point_,YOU_HAVE_TO_USE_A_VECTOR_OR_POINT_IN_THIS_METHOD)
  // check conditions
  if (T.range() != Q_.rows())
  { STKRUNTIME_ERROR_NO_ARG(Qr::pushBackCol,T.range() != Q_.rows());}
  // if Q_ is not computed yet
  if (!compq_) compQ();
  // Adding a column to R
  int lastColR = R_.endCols();
  // Create an auxiliary container
  VectorX Rncolr = Q_.transpose() * T; // Rncolr of size Q_.cols()
  // update Q_
  for (int iter = Q_.lastIdxCols()-1, iter1 = Q_.lastIdxCols(); iter>=lastColR; iter--, iter1--)
  {
    Real sinus, cosinus;
    // compute the Givens rotation
    Rncolr[iter] = compGivens( Rncolr[iter], Rncolr[iter1], cosinus, sinus);
    // apply Givens rotation if necessary
    if (sinus)
    { rightGivens(Q_, iter, iter1, cosinus, sinus);}
  }
  // update R_
  R_.pushBackCols();
  R_.col(lastColR).copy(Rncolr.sub(R_.rangeRowsInCol(lastColR)));
}

References STK::compGivens(), STK::Arrays::point_, STK::IQr< Qr >::pushBackCol(), STK::rightGivens(), STK_STATIC_ASSERT, STKRUNTIME_ERROR_NO_ARG, and STK::Arrays::vector_.

Q()

template<class Derived >

Array const & STK::IQr< Derived >::Q ( ) const

inline

give the matrix Q of the QR decomposition.

Returns

the matrix Q of the QR decomposition

Definition at line 155 of file STK_IQr.h.

{ return Q_;}

References STK::IQr< Derived >::Q_.

Referenced by STK::IQr< Derived >::IQr(), STK::IQr< Derived >::IQr(), and main().

R()

template<class Derived >

ArrayUpperTriangularXX const & STK::IQr< Derived >::R ( ) const

inline

give the matrix R of the QR decomposition.

Returns

the matrix R of the QR decomposition

Definition at line 159 of file STK_IQr.h.

{ return R_;}

References STK::IQr< Derived >::R_.

Referenced by main().

rank()

template<class Derived >

int STK::IQr< Derived >::rank ( ) const

inline

Returns

the rank of the matrix Q

Definition at line 151 of file STK_IQr.h.

{ return rank_;}

References STK::IQr< Derived >::rank_.

run()

template<class Derived >

bool STK::IQr< Derived >::run ( )

virtual

Compute the QR decomposition.

Delegate to Derived classes the concrete computation of the decomposition using runImpl method.

Returns

true if the computation succeed, false otherwise

Implements STK::IRunnerBase.

Definition at line 227 of file STK_IQr.h.

{
  // if Q is empty, default values are ok
  if (Q_.empty()) { compq_ = true; return true;}
  // compute QR decomposition
  if (!this->asDerived().runImpl()) return false;
  // compute Q if asked
  if (compq_) compQ();
  // compute rank_ using maximal number of R_
  int r = R_.beginRows();
  Real tol =  Arithmetic<Real>::epsilon() * std::abs(R_(r,r));
 
  int n = std::min(R_.endRows(), R_.endCols());
  for(r= R_.beginRows(), rank_=0; r<n; ++r, ++rank_) { if (std::abs(R_(r,r)) < tol) break;}
  return true;
}

Referenced by main().

setCompQ()

template<class Derived >

void STK::IQr< Derived >::setCompQ ( bool  compq )

inline

Set the compq_ flag.

By default compq is true.

Parameters

compq

true if we want to compute the Q matrix, false otherwise

Definition at line 165 of file STK_IQr.h.

{ compq_ = compq;}

References STK::IQr< Derived >::compq_.

setData()

template<class Derived >

template<class OtherDerived >

void STK::IQr< Derived >::setData ( ExprBase< OtherDerived > const &  data )

inline

overloading of setData.

Parameters

data	the data set to set.

Definition at line 204 of file STK_IQr.h.

    { Q_ = data.asDerived(); R_.clear(); compq_ = false; rank_ = 0;}

References STK::IArray2D< Derived >::clear(), STK::IQr< Derived >::compq_, STK::IQr< Derived >::Q_, STK::IQr< Derived >::R_, and STK::IQr< Derived >::rank_.

Member Data Documentation

compq_

template<class Derived >

bool STK::IQr< Derived >::compq_

protected

is Q computed ?

Definition at line 221 of file STK_IQr.h.

Referenced by STK::IQr< Derived >::isCompQ(), STK::IQr< Derived >::operator=(), STK::IQr< Derived >::setCompQ(), and STK::IQr< Derived >::setData().

Q_

template<class Derived >

Array STK::IQr< Derived >::Q_

protected

Q Array of the QR decomposition.

Definition at line 217 of file STK_IQr.h.

Referenced by STK::IQr< Derived >::IQr(), STK::IQr< Derived >::operator=(), STK::IQr< Derived >::Q(), and STK::IQr< Derived >::setData().

R_

template<class Derived >

ArrayUpperTriangularXX STK::IQr< Derived >::R_

protected

R Array of th QR decomposition.

Definition at line 219 of file STK_IQr.h.

Referenced by STK::IQr< Derived >::operator=(), STK::IQr< Derived >::R(), and STK::IQr< Derived >::setData().

rank_

template<class Derived >

int STK::IQr< Derived >::rank_

protected

estimated rank_ of the matrix A

Definition at line 223 of file STK_IQr.h.

Referenced by STK::IQr< Derived >::operator=(), STK::IQr< Derived >::rank(), and STK::IQr< Derived >::setData().

---

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

• STK_IQr.h