Class for matrix operations using GSL library. More...

#include <GslMatrix.h>

Inheritance diagram for QUESO::GslMatrix:

Collaboration diagram for QUESO::GslMatrix:

Public Member Functions
Constructor/Destructor methods
	GslMatrix ()
	Default Constructor. More...

	GslMatrix (const BaseEnvironment &env, const Map &map, unsigned int numCols)
	Shaped Constructor: creates a shaped matrix with `numCols` columns. More...

	GslMatrix (const BaseEnvironment &env, const Map &map, double diagValue)
	Shaped Constructor: creates a square matrix with size `map.NumGlobalElements()` and diagonal values all equal to `diagValue`. More...

	GslMatrix (const GslVector &v, double diagValue)
	Shaped Constructor: creates a square matrix with size `v.sizeLocal()` and diagonal values all equal to `diagValue`. More...

	GslMatrix (const GslVector &v)
	Shaped Constructor: creates a square matrix with size `v.sizeLocal()`. More...

	GslMatrix (const GslMatrix &B)
	Shaped Constructor: creates a matrix with `B.numCols()` columns and `B.numRowsLocal()` rows. More...

	~GslMatrix ()
	Destructor. More...

Set methods
GslMatrix &	operator= (const GslMatrix &rhs)
	Copies values from matrix `rhs` to `this`. More...

GslMatrix &	operator*= (double a)
	Stores in `this` the coordinate-wise multiplication of `this` and `a`. More...

GslMatrix &	operator/= (double a)
	Stores in `this` the coordinate-wise division of `this` by `a`. More...

GslMatrix &	operator+= (const GslMatrix &rhs)
	Stores in `this` the coordinate-wise addition of `this` and `rhs`. More...

GslMatrix &	operator-= (const GslMatrix &rhs)
	Stores in `this` the coordinate-wise subtraction of `this` by `rhs`. More...

Accessor methods
double &	operator() (unsigned int i, unsigned int j)
	Element access method (non-const). More...

const double &	operator() (unsigned int i, unsigned int j) const
	Element access method (const). More...

Attribute methods
unsigned int	numRowsLocal () const
	Returns the local row dimension of `this` matrix. More...

unsigned int	numRowsGlobal () const
	Returns the global row dimension of `this` matrix. More...

unsigned int	numCols () const
	Returns the column dimension of `this` matrix. More...

double	max () const
	Returns the maximum element value of the matrix. More...

unsigned int	rank (double absoluteZeroThreshold, double relativeZeroThreshold) const
	This function returns the number of singular values of `this` matrix (rank). More...

GslMatrix	transpose () const
	This function calculated the transpose of `this` matrix (square). More...

GslMatrix	inverse () const
	This function calculated the inverse of `this` matrix (square). More...

double	determinant () const
	Calculates the determinant of `this` matrix. More...

double	lnDeterminant () const
	Calculates the ln(determinant) of `this` matrix. More...

Norm methods
double	normFrob () const
	Returns the Frobenius norm of `this` matrix. More...

double	normMax () const
	Returns the Frobenius norm of `this` matrix. More...

Mathematical methods
int	chol ()
	Computes Cholesky factorization of a real symmetric positive definite matrix `this`. More...

int	svd (GslMatrix &matU, GslVector &vecS, GslMatrix &matVt) const
	Checks for the dimension of `this` matrix, `matU`, `VecS` and `matVt`, and calls the protected routine `internalSvd` to compute the singular values of `this`. More...

const GslMatrix &	svdMatU () const
	This function calls private member GslMatrix::internalSvd() to set a M-by-N orthogonal matrix U of the singular value decomposition (svd) of a general rectangular M-by-N matrix A. More...

const GslMatrix &	svdMatV () const
	This function calls private member GslMatrix::internalSvd() to set a N-by-N orthogonal square matrix V of the singular value decomposition (svd) of a general rectangular M-by-N matrix A. More...

int	svdSolve (const GslVector &rhsVec, GslVector &solVec) const
	This function solves the system A x = b using the singular value decomposition (U, S, V) of A which must have been computed previously with GslMatrix::svd (x=solVec, b=rhsVec). More...

int	svdSolve (const GslMatrix &rhsMat, GslMatrix &solMat) const
	This function solves the system A x = b using the singular value decomposition (U, S, V) of A which must have been computed previously with GslMatrix::svd (x=solMat, b=rhsMat). More...

GslVector	multiply (const GslVector &x) const
	This function multiplies `this` matrix by vector `x` and returns the resulting vector. More...

GslVector	invertMultiply (const GslVector &b) const
	This function calculates the inverse of `this` matrix and multiplies it with vector `b`. More...

void	invertMultiply (const GslVector &b, GslVector &x) const
	This function calculates the inverse of `this` matrix, multiplies it with vector `b` and stores the result in vector `x`. More...

GslMatrix	invertMultiply (const GslMatrix &B) const
	This function calculates the inverse of `this` matrix and multiplies it with matrix `B`. More...

void	invertMultiply (const GslMatrix &B, GslMatrix &X) const
	This function calculates the inverse of `this` matrix, multiplies it with matrix `B` and stores the result in matrix `X`. More...

GslVector	invertMultiplyForceLU (const GslVector &b) const
	This function calculates the inverse of `this` matrix and multiplies it with vector `b`. More...

void	invertMultiplyForceLU (const GslVector &b, GslVector &x) const
	This function calculates the inverse of `this` matrix, multiplies it with vector `b` and stores the result in vector `x`. More...

void	getColumn (const unsigned int column_num, GslVector &column) const
	This function gets the column_num-th column of `this` matrix and stores it into vector `column`. More...

GslVector	getColumn (const unsigned int column_num) const
	This function gets the column_num-th column of `this` matrix. More...

void	setColumn (const unsigned int column_num, const GslVector &column)
	This function copies vector `column` into the column_num-th column of `this` matrix. More...

void	getRow (const unsigned int row_num, GslVector &row) const
	This function gets the row_num-th column of `this` matrix and stores it into vector `row`. More...

GslVector	getRow (const unsigned int row_num) const
	This function gets the row_num-th column of `this` matrix. More...

void	setRow (const unsigned int row_num, const GslVector &row)
	This function copies vector `row` into the row_num-th column of `this` matrix. More...

void	eigen (GslVector &eigenValues, GslMatrix *eigenVectors) const
	This function computes the eigenvalues of a real symmetric matrix. More...

void	largestEigen (double &eigenValue, GslVector &eigenVector) const
	This function finds largest eigenvalue, namely `eigenValue`, of `this` matrix and its corresponding eigenvector, namely `eigenVector`. More...

void	smallestEigen (double &eigenValue, GslVector &eigenVector) const
	This function finds smallest eigenvalue, namely `eigenValue`, of `this` matrix and its corresponding eigenvector, namely `eigenVector`. More...

Get/Set methods
void	cwSet (double value)
	Component-wise set all values to `this` with value. More...

void	cwSet (unsigned int rowId, unsigned int colId, const GslMatrix &mat)
	Set the components of `which` positions are greater than (rowId,colId) with the value of mat(rowId,colId). More...

void	cwExtract (unsigned int rowId, unsigned int colId, GslMatrix &mat) const

void	zeroLower (bool includeDiagonal=false)
	This function sets all the entries bellow the main diagonal of `this` matrix to zero. More...

void	zeroUpper (bool includeDiagonal=false)
	This function sets all the entries above the main diagonal of `this` matrix to zero. More...

void	filterSmallValues (double thresholdValue)
	This function sets to zero (filters) all entries of `this` matrix which are smaller than `thresholdValue`. More...

void	filterLargeValues (double thresholdValue)
	This function sets to zero (filters) all entries of `this` matrix which are greater than `thresholdValue`. More...

void	fillWithTranspose (unsigned int rowId, unsigned int colId, const GslMatrix &mat, bool checkForExactNumRowsMatching, bool checkForExactNumColsMatching)
	This function stores the transpose of `this` matrix into `this` matrix. More...

void	fillWithBlocksDiagonally (unsigned int rowId, unsigned int colId, const std::vector< const GslMatrix * > &matrices, bool checkForExactNumRowsMatching, bool checkForExactNumColsMatching)
	This function fills `this` matrix diagonally with const block matrices. More...

void	fillWithBlocksDiagonally (unsigned int rowId, unsigned int colId, const std::vector< GslMatrix * > &matrices, bool checkForExactNumRowsMatching, bool checkForExactNumColsMatching)
	This function fills `this` matrix diagonally with block matrices. More...

void	fillWithBlocksHorizontally (unsigned int rowId, unsigned int colId, const std::vector< const GslMatrix * > &matrices, bool checkForExactNumRowsMatching, bool checkForExactNumColsMatching)
	This function fills `this` matrix horizontally with const block matrices. More...

void	fillWithBlocksHorizontally (unsigned int rowId, unsigned int colId, const std::vector< GslMatrix * > &matrices, bool checkForExactNumRowsMatching, bool checkForExactNumColsMatching)
	This function fills `this` matrix horizontally with const block. More...

void	fillWithBlocksVertically (unsigned int rowId, unsigned int colId, const std::vector< const GslMatrix * > &matrices, bool checkForExactNumRowsMatching, bool checkForExactNumColsMatching)
	This function fills `this` matrix vertically with const block matrices. More...

void	fillWithBlocksVertically (unsigned int rowId, unsigned int colId, const std::vector< GslMatrix * > &matrices, bool checkForExactNumRowsMatching, bool checkForExactNumColsMatching)
	This function fills `this` matrix vertically with block matrices. More...

void	fillWithTensorProduct (unsigned int rowId, unsigned int colId, const GslMatrix &mat1, const GslMatrix &mat2, bool checkForExactNumRowsMatching, bool checkForExactNumColsMatching)
	This function calculates the tensor product of matrices `mat1` and `mat2` and stores it in `this` matrix. More...

void	fillWithTensorProduct (unsigned int rowId, unsigned int colId, const GslMatrix &mat1, const GslVector &vec2, bool checkForExactNumRowsMatching, bool checkForExactNumColsMatching)
	This function calculates the tensor product of matrix `mat1` and vector `vec2` and stores it in `this` matrix. More...

Miscellaneous methods
gsl_matrix *	data ()
	Returns `this` matrix. More...

void	mpiSum (const MpiComm &comm, GslMatrix &M_global) const

void	matlabLinearInterpExtrap (const GslVector &x1Vec, const GslMatrix &y1Mat, const GslVector &x2Vec)

I/O methods
void	print (std::ostream &os) const
	Print method. Defines the behavior of the ostream << operator inherited from the Object class. More...

void	subWriteContents (const std::string &varNamePrefix, const std::string &fileName, const std::string &fileType, const std::set< unsigned int > &allowedSubEnvIds) const
	Write contents of subenvironment in file `fileName`. More...

void	subReadContents (const std::string &fileName, const std::string &fileType, const std::set< unsigned int > &allowedSubEnvIds)
	Read contents of subenvironment from file `fileName`. More...

Public Member Functions inherited from QUESO::Matrix
	Matrix ()
	Default constructor. More...

	Matrix (const BaseEnvironment &env, const Map &map)
	Shaped constructor. More...

	Matrix (const Matrix &rhs)
	Copy constructor. More...

virtual	~Matrix ()
	Virtual Destructor. More...

Matrix &	operator= (const Matrix &rhs)
	Operator for copying a matrix. More...

Matrix &	operator*= (double a)
	Operator for multiplication of the matrix by a scalar. More...

Matrix &	operator+= (const Matrix &rhs)
	Operator for addition (element-wise) of two matrices. More...

Matrix &	operator-= (const Matrix &rhs)
	Operator for subtraction (element-wise) of two matrices. More...

const BaseEnvironment &	env () const

const Map &	map () const

unsigned int	numOfProcsForStorage () const

void	setPrintHorizontally (bool value) const
	Determines whether the matrix should be printed horizontally. More...

bool	getPrintHorizontally () const
	Checks if matrix will be is printed horizontally. More...

void	setInDebugMode (bool value) const
	Determines whether QUESO will run through this class in debug mode. More...

bool	getInDebugMode () const
	Checks if QUESO will run through this class in debug mode. More...

Private Member Functions
void	copy (const GslMatrix &src)
	In this function `this` matrix receives a copy of matrix `src`. More...

void	resetLU ()
	In this function resets the LU decomposition of `this` matrix, as well as deletes the private member pointers, if existing. More...

void	multiply (const GslVector &x, GslVector &y) const
	This function multiplies `this` matrix by vector `x` and stores the resulting vector in `y`. More...

int	internalSvd () const
	This function factorizes the M-by-N matrix A into the singular value decomposition A = U S V^T for M >= N. On output the matrix A is replaced by U. More...

Private Attributes
gsl_matrix *	m_mat
	GSL matrix, also referred to as `this` matrix. More...

gsl_matrix *	m_LU
	GSL matrix for the LU decomposition of m_mat. More...

GslMatrix *	m_inverse
	Inverse matrix of `this`. More...

Map *	m_svdColMap
	Mapping for matrices involved in the singular value decomposition (svd) routine. More...

GslMatrix *	m_svdUmat
	m_svdUmat stores the M-by-N orthogonal matrix U after the singular value decomposition of a matrix. More...

GslVector *	m_svdSvec
	m_svdSvec stores the diagonal of the N-by-N diagonal matrix of singular values S after the singular value decomposition of a matrix. More...

GslMatrix *	m_svdVmat
	m_svdVmat stores the N-by-N orthogonal square matrix V after the singular value decomposition of a matrix. More...

GslMatrix *	m_svdVTmat
	m_svdVmatT stores the transpose of N-by-N orthogonal square matrix V, namely V^T, after the singular value decomposition of a matrix. More...

double	m_determinant
	The determinant of `this` matrix. More...

double	m_lnDeterminant
	The natural logarithm of the determinant of `this` matrix. More...

gsl_permutation *	m_permutation
	The permutation matrix of a LU decomposition. More...

int	m_signum
	m_signum stores the sign of the permutation of the LU decomposition PA = LU. More...

bool	m_isSingular
	Indicates whether or not `this` matrix is singular. More...

Additional Inherited Members
Protected Member Functions inherited from QUESO::Matrix
virtual void	copy (const Matrix &src)
	Copies matrix `src` to `this` matrix. More...

Protected Attributes inherited from QUESO::Matrix
const BaseEnvironment &	m_env
	QUESO environment variable. More...

const Map &	m_map
	Mapping variable. More...

bool	m_printHorizontally
	Flag for either or not print this matrix. More...

bool	m_inDebugMode
	Flag for either or not QUESO is in debug mode. More...

Detailed Description

Class for matrix operations using GSL library.

This class creates and provides basic support for matrices of templated type as a specialization of Matrix using GSL matrices, which are defined by an encapsulated gsl_matrix structure.

Definition at line 47 of file GslMatrix.h.

Constructor & Destructor Documentation

QUESO::GslMatrix::GslMatrix ( )

Default Constructor.

Creates an empty matrix vector of no dimension. It should not be used by user.

Definition at line 36 of file GslMatrix.C.

References QUESO::Matrix::m_env, UQ_FATAL_TEST_MACRO, and QUESO::BaseEnvironment::worldRank().

Referenced by internalSvd(), and inverse().

   :
   Matrix()
 {
   UQ_FATAL_TEST_MACRO(true,
                       m_env.worldRank(),
                       "GslMatrix::constructor(), default",
                       "should not be used by user");
 }

QUESO::GslMatrix::GslMatrix	(	const BaseEnvironment &	env,
		const Map &	map,
		unsigned int	numCols
	)

Shaped Constructor: creates a shaped matrix with numCols columns.

Definition at line 46 of file GslMatrix.C.

References QUESO::Matrix::m_env, m_mat, UQ_FATAL_TEST_MACRO, and QUESO::BaseEnvironment::worldRank().

   :
   Matrix  (env,map),
   m_mat          (gsl_matrix_calloc(map.NumGlobalElements(),nCols)),
   m_LU           (NULL),
   m_inverse      (NULL),
   m_svdColMap    (NULL),
   m_svdUmat      (NULL),
   m_svdSvec      (NULL),
   m_svdVmat      (NULL),
   m_svdVTmat     (NULL),
   m_determinant  (-INFINITY),
   m_lnDeterminant(-INFINITY),
   m_permutation  (NULL),
   m_signum       (0),
   m_isSingular   (false)
 {
   UQ_FATAL_TEST_MACRO((m_mat == NULL),
                       m_env.worldRank(),
                       "GslMatrix::constructor()",
                       "null matrix generated");
 }

QUESO::GslMatrix::GslMatrix	(	const BaseEnvironment &	env,
		const Map &	map,
		double	diagValue
	)

Shaped Constructor: creates a square matrix with size map.NumGlobalElements() and diagonal values all equal to diagValue.

Definition at line 73 of file GslMatrix.C.

References QUESO::Matrix::m_env, m_mat, UQ_FATAL_TEST_MACRO, and QUESO::BaseEnvironment::worldRank().

   :
   Matrix  (env,map),
   m_mat          (gsl_matrix_calloc(map.NumGlobalElements(),map.NumGlobalElements())),
   m_LU           (NULL),
   m_inverse      (NULL),
   m_svdColMap    (NULL),
   m_svdUmat      (NULL),
   m_svdSvec      (NULL),
   m_svdVmat      (NULL),
   m_svdVTmat     (NULL),
   m_determinant  (-INFINITY),
   m_lnDeterminant(-INFINITY),
   m_permutation  (NULL),
   m_signum       (0),
   m_isSingular   (false)
 {
   UQ_FATAL_TEST_MACRO((m_mat == NULL),
                       m_env.worldRank(),
                       "GslMatrix::constructor(), eye",
                       "null matrix generated");
 
   for (unsigned int i = 0; i < m_mat->size1; ++i) {
     (*this)(i,i) = diagValue;
   }
 }

QUESO::GslMatrix::GslMatrix	(	const GslVector &	v,
		double	diagValue
	)

Shaped Constructor: creates a square matrix with size v.sizeLocal() and diagonal values all equal to diagValue.

Definition at line 103 of file GslMatrix.C.

References QUESO::Matrix::m_env, m_mat, UQ_FATAL_TEST_MACRO, and QUESO::BaseEnvironment::worldRank().

   :
   Matrix  (v.env(),v.map()),
   m_mat          (gsl_matrix_calloc(v.sizeLocal(),v.sizeLocal())),
   m_LU           (NULL),
   m_inverse      (NULL),
   m_svdColMap    (NULL),
   m_svdUmat      (NULL),
   m_svdSvec      (NULL),
   m_svdVmat      (NULL),
   m_svdVTmat     (NULL),
   m_determinant  (-INFINITY),
   m_lnDeterminant(-INFINITY),
   m_permutation  (NULL),
   m_signum       (0),
   m_isSingular   (false)
 {
   UQ_FATAL_TEST_MACRO((m_mat == NULL),
                       m_env.worldRank(),
                       "GslMatrix::constructor(), eye",
                       "null matrix generated");
 
   for (unsigned int i = 0; i < m_mat->size1; ++i) {
     (*this)(i,i) = diagValue;
   }
 }

QUESO::GslMatrix::GslMatrix ( const GslVector & v )

Shaped Constructor: creates a square matrix with size v.sizeLocal().

The diagonal values of this matrix are the elements in vector v.

Definition at line 132 of file GslMatrix.C.

References QUESO::Matrix::m_env, m_mat, QUESO::GslVector::sizeLocal(), UQ_FATAL_TEST_MACRO, and QUESO::BaseEnvironment::worldRank().

   :
   Matrix  (v.env(),v.map()),
   m_mat          (gsl_matrix_calloc(v.sizeLocal(),v.sizeLocal())),
   m_LU           (NULL),
   m_inverse      (NULL),
   m_svdColMap    (NULL),
   m_svdUmat      (NULL),
   m_svdSvec      (NULL),
   m_svdVmat      (NULL),
   m_svdVTmat     (NULL),
   m_determinant  (-INFINITY),
   m_lnDeterminant(-INFINITY),
   m_permutation  (NULL),
   m_signum       (0),
   m_isSingular   (false)
 {
   UQ_FATAL_TEST_MACRO((m_mat == NULL),
                       m_env.worldRank(),
                       "GslMatrix::constructor(), from vector",
                       "null matrix generated");
 
   unsigned int dim = v.sizeLocal();
   for (unsigned int i = 0; i < dim; ++i) {
     (*this)(i,i) = v[i];
   }
 }

QUESO::GslMatrix::GslMatrix ( const GslMatrix & B )

Shaped Constructor: creates a matrix with B.numCols() columns and B.numRowsLocal() rows.

This matrix is a copy of matrix B.

Definition at line 161 of file GslMatrix.C.

References QUESO::Matrix::copy(), copy(), QUESO::Matrix::m_env, m_mat, UQ_FATAL_TEST_MACRO, and QUESO::BaseEnvironment::worldRank().

   :
   Matrix  (B.env(),B.map()),
   m_mat          (gsl_matrix_calloc(B.numRowsLocal(),B.numCols())),
   m_LU           (NULL),
   m_inverse      (NULL),
   m_svdColMap    (NULL),
   m_svdUmat      (NULL),
   m_svdSvec      (NULL),
   m_svdVmat      (NULL),
   m_svdVTmat     (NULL),
   m_determinant  (-INFINITY),
   m_lnDeterminant(-INFINITY),
   m_permutation  (NULL),
   m_signum       (0),
   m_isSingular   (false)
 {
   UQ_FATAL_TEST_MACRO((m_mat == NULL),
                       m_env.worldRank(),
                       "GslMatrix::constructor(), copy",
                       "null vector generated");
   this->Matrix::copy(B);
   this->copy(B);
 }

QUESO::GslMatrix::~GslMatrix ( )

Destructor.

Definition at line 187 of file GslMatrix.C.

References m_mat, and resetLU().

 {
   this->resetLU();
   if (m_mat) gsl_matrix_free(m_mat);
 }

Member Function Documentation

int QUESO::GslMatrix::chol ( )

virtual

Computes Cholesky factorization of a real symmetric positive definite matrix this.

In case fails to be symmetric and positive definite, an error will be returned.

Implements QUESO::Matrix.

Definition at line 506 of file GslMatrix.C.

References QUESO::Matrix::m_env, m_mat, QUESO::UQ_MATRIX_IS_NOT_POS_DEFINITE_RC, UQ_RC_MACRO, and QUESO::BaseEnvironment::worldRank().

 {
   int iRC;
   //std::cout << "Calling gsl_linalg_cholesky_decomp()..." << std::endl;
   gsl_error_handler_t* oldHandler;
   oldHandler = gsl_set_error_handler_off();
   iRC = gsl_linalg_cholesky_decomp(m_mat);
   if (iRC != 0) {
     std::cerr << "In GslMatrix::chol()"
               << ": iRC = " << iRC
               << ", gsl error message = " << gsl_strerror(iRC)
               << std::endl;
     std::cerr << "Here is the offending matrix: " << std::endl;
     std::cerr << *this << std::endl;
   }
   gsl_set_error_handler(oldHandler);
   //std::cout << "Returned from gsl_linalg_cholesky_decomp() with iRC = " << iRC << std::endl;
   UQ_RC_MACRO(iRC, // Yes, *not* a fatal check on RC
               m_env.worldRank(),
               "GslMatrix::chol()",
               "matrix is not positive definite",
               UQ_MATRIX_IS_NOT_POS_DEFINITE_RC);
 
   return iRC;
 }

void QUESO::GslMatrix::copy ( const GslMatrix & src )

private

In this function this matrix receives a copy of matrix src.

Definition at line 292 of file GslMatrix.C.

References QUESO::Matrix::m_env, m_mat, resetLU(), UQ_FATAL_RC_MACRO, and QUESO::BaseEnvironment::worldRank().

Referenced by GslMatrix(), and operator=().

 {
   this->resetLU();
   int iRC;
   iRC = gsl_matrix_memcpy(this->m_mat, src.m_mat);
   UQ_FATAL_RC_MACRO(iRC,
                     m_env.worldRank(),
                     "GslMatrix::copy()",
                     "failed");
 
   return;
 }

void QUESO::GslMatrix::cwExtract	(	unsigned int	rowId,
		unsigned int	colId,
		GslMatrix &	mat
	)		const

Definition at line 471 of file GslMatrix.C.

References QUESO::Matrix::m_env, numCols(), numRowsLocal(), UQ_FATAL_TEST_MACRO, and QUESO::BaseEnvironment::worldRank().

 {
   UQ_FATAL_TEST_MACRO(initialTargetRowId >= this->numRowsLocal(),
                       m_env.worldRank(),
                       "GslMatrix::cwExtract()",
                       "invalid initialTargetRowId");
 
   UQ_FATAL_TEST_MACRO((initialTargetRowId + mat.numRowsLocal()) > this->numRowsLocal(),
                       m_env.worldRank(),
                       "GslMatrix::cwExtract()",
                       "invalid vec.numRowsLocal()");
 
   UQ_FATAL_TEST_MACRO(initialTargetColId >= this->numCols(),
                       m_env.worldRank(),
                       "GslMatrix::cwExtract()",
                       "invalid initialTargetColId");
 
   UQ_FATAL_TEST_MACRO((initialTargetColId + mat.numCols()) > this->numCols(),
                       m_env.worldRank(),
                       "GslMatrix::cwExtract()",
                       "invalid vec.numCols()");
 
   for (unsigned int i = 0; i < mat.numRowsLocal(); ++i) {
     for (unsigned int j = 0; j < mat.numCols(); ++j) {
       mat(i,j) = (*this)(initialTargetRowId+i,initialTargetColId+j) ;
     }
   }
 
   return;
 }

void QUESO::GslMatrix::cwSet ( double value )

Component-wise set all values to this with value.

Definition at line 421 of file GslMatrix.C.

References m_mat, numCols(), and numRowsLocal().

 {
   unsigned int nRows = this->numRowsLocal();
   unsigned int nCols = this->numCols();
 
   for (unsigned int row = 0; row < nRows; ++row) {
     for (unsigned int col = 0; col < nCols; ++col) {
       *gsl_matrix_ptr(m_mat,row,col) = value;
     }
   }
 
   return;
 }

void QUESO::GslMatrix::cwSet	(	unsigned int	rowId,
		unsigned int	colId,
		const GslMatrix &	mat
	)

Set the components of which positions are greater than (rowId,colId) with the value of mat(rowId,colId).

Definition at line 436 of file GslMatrix.C.

References QUESO::Matrix::m_env, numCols(), numRowsLocal(), UQ_FATAL_TEST_MACRO, and QUESO::BaseEnvironment::worldRank().

 {
   UQ_FATAL_TEST_MACRO(initialTargetRowId >= this->numRowsLocal(),
                       m_env.worldRank(),
                       "GslMatrix::cwSet()",
                       "invalid initialTargetRowId");
 
   UQ_FATAL_TEST_MACRO((initialTargetRowId + mat.numRowsLocal()) > this->numRowsLocal(),
                       m_env.worldRank(),
                       "GslMatrix::cwSet()",
                       "invalid vec.numRowsLocal()");
 
   UQ_FATAL_TEST_MACRO(initialTargetColId >= this->numCols(),
                       m_env.worldRank(),
                       "GslMatrix::cwSet()",
                       "invalid initialTargetColId");
 
   UQ_FATAL_TEST_MACRO((initialTargetColId + mat.numCols()) > this->numCols(),
                       m_env.worldRank(),
                       "GslMatrix::cwSet()",
                       "invalid vec.numCols()");
 
   for (unsigned int i = 0; i < mat.numRowsLocal(); ++i) {
     for (unsigned int j = 0; j < mat.numCols(); ++j) {
       (*this)(initialTargetRowId+i,initialTargetColId+j) = mat(i,j);
     }
   }
 
   return;
 }

gsl_matrix * QUESO::GslMatrix::data ( )

Returns this matrix.

Definition at line 2108 of file GslMatrix.C.

References m_mat.

Referenced by internalSvd(), and svdSolve().

 {
   return m_mat;
 }

double QUESO::GslMatrix::determinant ( ) const

Calculates the determinant of this matrix.

Definition at line 1281 of file GslMatrix.C.

References QUESO::BaseEnvironment::displayVerbosity(), invertMultiply(), m_determinant, QUESO::Matrix::m_env, m_lnDeterminant, m_LU, QUESO::Matrix::m_map, m_signum, and QUESO::BaseEnvironment::subDisplayFile().

 {
   if (m_determinant == -INFINITY) {
     if (m_LU == NULL) {
       GslVector tmpB(m_env,m_map);
       GslVector tmpX(m_env,m_map);
       if ((m_env.subDisplayFile()) && (m_env.displayVerbosity() >= 99)) {
         *m_env.subDisplayFile() << "In GslMatrix::determinant()"
                                 << ": before 'this->invertMultiply()'"
                                 << std::endl;
       }
       this->invertMultiply(tmpB,tmpX);
       if ((m_env.subDisplayFile()) && (m_env.displayVerbosity() >= 99)) {
         *m_env.subDisplayFile() << "In GslMatrix::determinant()"
                                 << ": after 'this->invertMultiply()'"
                                 << std::endl;
       }
     }
     if ((m_env.subDisplayFile()) && (m_env.displayVerbosity() >= 99)) {
       *m_env.subDisplayFile() << "In GslMatrix::determinant()"
                               << ": before 'gsl_linalg_LU_det()'"
                               << std::endl;
     }
     m_determinant   = gsl_linalg_LU_det(m_LU,m_signum);
     if ((m_env.subDisplayFile()) && (m_env.displayVerbosity() >= 99)) {
       *m_env.subDisplayFile() << "In GslMatrix::determinant()"
                               << ": after 'gsl_linalg_LU_det()'"
                               << std::endl;
     }
     m_lnDeterminant = gsl_linalg_LU_lndet(m_LU);
     if ((m_env.subDisplayFile()) && (m_env.displayVerbosity() >= 99)) {
       *m_env.subDisplayFile() << "In GslMatrix::determinant()"
                               << ": after 'gsl_linalg_LU_lndet()'"
                               << std::endl;
     }
   }
 
   return m_determinant;
 }

void QUESO::GslMatrix::eigen	(	GslVector &	eigenValues,
		GslMatrix *	eigenVectors
	)		const

This function computes the eigenvalues of a real symmetric matrix.

Definition at line 1696 of file GslMatrix.C.

References QUESO::GslVector::data(), QUESO::Matrix::env(), QUESO::BaseEnvironment::fullRank(), m_mat, numRowsLocal(), QUESO::GslVector::sizeLocal(), and UQ_FATAL_TEST_MACRO.

 {
   unsigned int n = eigenValues.sizeLocal();
 
   UQ_FATAL_TEST_MACRO((n == 0),
                       env().fullRank(),
                       "GslMatrix::eigen()",
                       "invalid input vector size");
 
   if (eigenVectors) {
     UQ_FATAL_TEST_MACRO((eigenValues.sizeLocal() != eigenVectors->numRowsLocal()),
                         env().fullRank(),
                         "GslVector::eigen()",
                         "different input vector sizes");
   }
 
   if (eigenVectors == NULL) {
     gsl_eigen_symm_workspace* w = gsl_eigen_symm_alloc((size_t) n);
     gsl_eigen_symm(m_mat,eigenValues.data(),w);
     gsl_eigen_symm_free(w);
   }
   else {
     gsl_eigen_symmv_workspace* w = gsl_eigen_symmv_alloc((size_t) n);
     gsl_eigen_symmv(m_mat,eigenValues.data(),eigenVectors->m_mat,w);
     gsl_eigen_symmv_sort(eigenValues.data(),eigenVectors->m_mat,GSL_EIGEN_SORT_VAL_ASC);
     gsl_eigen_symmv_free(w);
   }
 
   return;
 }

void QUESO::GslMatrix::fillWithBlocksDiagonally	(	unsigned int	rowId,
		unsigned int	colId,
		const std::vector< const GslMatrix * > &	matrices,
		bool	checkForExactNumRowsMatching,
		bool	checkForExactNumColsMatching
	)

This function fills this matrix diagonally with const block matrices.

Definition at line 888 of file GslMatrix.C.

References QUESO::Matrix::m_env, numCols(), numRowsLocal(), UQ_FATAL_TEST_MACRO, and QUESO::BaseEnvironment::worldRank().

 {
   unsigned int sumNumRowsLocals = 0;
   unsigned int sumNumCols       = 0;
   for (unsigned int i = 0; i < matrices.size(); ++i) {
     sumNumRowsLocals += matrices[i]->numRowsLocal();
     sumNumCols       += matrices[i]->numCols();
   }
   UQ_FATAL_TEST_MACRO(this->numRowsLocal() < (initialTargetRowId + sumNumRowsLocals),
                       m_env.worldRank(),
                       "GslMatrix::fillWithBlocksDiagonally(const)",
                       "too big number of rows");
   UQ_FATAL_TEST_MACRO(checkForExactNumRowsMatching && (this->numRowsLocal() != (initialTargetRowId + sumNumRowsLocals)),
                       m_env.worldRank(),
                       "GslMatrix::fillWithBlocksDiagonally(const)",
                       "inconsistent number of rows");
   UQ_FATAL_TEST_MACRO(this->numCols() < (initialTargetColId + sumNumCols),
                       m_env.worldRank(),
                       "GslMatrix::fillWithBlocksDiagonally(const)",
                       "too big number of cols");
   UQ_FATAL_TEST_MACRO(checkForExactNumColsMatching && (this->numCols() != (initialTargetColId + sumNumCols)),
                       m_env.worldRank(),
                       "GslMatrix::fillWithBlocksDiagonally(const)",
                       "inconsistent number of cols");
 
   unsigned int cumulativeRowId = 0;
   unsigned int cumulativeColId = 0;
   for (unsigned int i = 0; i < matrices.size(); ++i) {
     unsigned int nRows = matrices[i]->numRowsLocal();
     unsigned int nCols = matrices[i]->numCols();
     for (unsigned int rowId = 0; rowId < nRows; ++rowId) {
       for (unsigned int colId = 0; colId < nCols; ++colId) {
         (*this)(initialTargetRowId + cumulativeRowId + rowId, initialTargetColId + cumulativeColId + colId) = (*(matrices[i]))(rowId,colId);
       }
     }
     cumulativeRowId += nRows;
     cumulativeColId += nCols;
   }
 
   return;
 }

void QUESO::GslMatrix::fillWithBlocksDiagonally	(	unsigned int	rowId,
		unsigned int	colId,
		const std::vector< GslMatrix * > &	matrices,
		bool	checkForExactNumRowsMatching,
		bool	checkForExactNumColsMatching
	)

This function fills this matrix diagonally with block matrices.

Definition at line 936 of file GslMatrix.C.

References QUESO::Matrix::m_env, numCols(), numRowsLocal(), UQ_FATAL_TEST_MACRO, and QUESO::BaseEnvironment::worldRank().

 {
   unsigned int sumNumRowsLocals = 0;
   unsigned int sumNumCols       = 0;
   for (unsigned int i = 0; i < matrices.size(); ++i) {
     sumNumRowsLocals += matrices[i]->numRowsLocal();
     sumNumCols       += matrices[i]->numCols();
   }
   UQ_FATAL_TEST_MACRO(this->numRowsLocal() < (initialTargetRowId + sumNumRowsLocals),
                       m_env.worldRank(),
                       "GslMatrix::fillWithBlocksDiagonally()",
                       "too big number of rows");
   UQ_FATAL_TEST_MACRO(checkForExactNumRowsMatching && (this->numRowsLocal() != (initialTargetRowId + sumNumRowsLocals)),
                       m_env.worldRank(),
                       "GslMatrix::fillWithBlocksDiagonally()",
                       "inconsistent number of rows");
   UQ_FATAL_TEST_MACRO(this->numCols() < (initialTargetColId + sumNumCols),
                       m_env.worldRank(),
                       "GslMatrix::fillWithBlocksDiagonally()",
                       "too big number of cols");
   UQ_FATAL_TEST_MACRO(checkForExactNumColsMatching && (this->numCols() != (initialTargetColId + sumNumCols)),
                       m_env.worldRank(),
                       "GslMatrix::fillWithBlocksDiagonally()",
                       "inconsistent number of cols");
 
   unsigned int cumulativeRowId = 0;
   unsigned int cumulativeColId = 0;
   for (unsigned int i = 0; i < matrices.size(); ++i) {
     unsigned int nRows = matrices[i]->numRowsLocal();
     unsigned int nCols = matrices[i]->numCols();
     for (unsigned int rowId = 0; rowId < nRows; ++rowId) {
       for (unsigned int colId = 0; colId < nCols; ++colId) {
         (*this)(initialTargetRowId + cumulativeRowId + rowId, initialTargetColId + cumulativeColId + colId) = (*(matrices[i]))(rowId,colId);
       }
     }
     cumulativeRowId += nRows;
     cumulativeColId += nCols;
   }
 
   return;
 }

void QUESO::GslMatrix::fillWithBlocksHorizontally	(	unsigned int	rowId,
		unsigned int	colId,
		const std::vector< const GslMatrix * > &	matrices,
		bool	checkForExactNumRowsMatching,
		bool	checkForExactNumColsMatching
	)

This function fills this matrix horizontally with const block matrices.

Definition at line 984 of file GslMatrix.C.

References QUESO::Matrix::m_env, numCols(), numRowsLocal(), UQ_FATAL_TEST_MACRO, and QUESO::BaseEnvironment::worldRank().

 {
   unsigned int sumNumCols = 0;
   for (unsigned int i = 0; i < matrices.size(); ++i) {
     UQ_FATAL_TEST_MACRO(this->numRowsLocal() < (initialTargetRowId + matrices[i]->numRowsLocal()),
                         m_env.worldRank(),
                         "GslMatrix::fillWithBlocksHorizontally(const)",
                         "too big number of rows");
     UQ_FATAL_TEST_MACRO(checkForExactNumRowsMatching && (this->numRowsLocal() != (initialTargetRowId + matrices[i]->numRowsLocal())),
                         m_env.worldRank(),
                         "GslMatrix::fillWithBlocksHorizontally(const)",
                         "inconsistent number of rows");
     sumNumCols += matrices[i]->numCols();
   }
   UQ_FATAL_TEST_MACRO(this->numCols() < (initialTargetColId + sumNumCols),
                       m_env.worldRank(),
                       "GslMatrix::fillWithBlocksHorizontally(const)",
                       "too big number of cols");
   UQ_FATAL_TEST_MACRO(checkForExactNumColsMatching && (this->numCols() != (initialTargetColId + sumNumCols)),
                       m_env.worldRank(),
                       "GslMatrix::fillWithBlocksHorizontally(const)",
                       "inconsistent number of cols");
 
   unsigned int cumulativeColId = 0;
   for (unsigned int i = 0; i < matrices.size(); ++i) {
     unsigned int nRows = matrices[i]->numRowsLocal();
     unsigned int nCols = matrices[i]->numCols();
     for (unsigned int rowId = 0; rowId < nRows; ++rowId) {
       for (unsigned int colId = 0; colId < nCols; ++colId) {
         (*this)(initialTargetRowId + rowId, initialTargetColId + cumulativeColId + colId) = (*(matrices[i]))(rowId,colId);
       }
     }
     cumulativeColId += nCols;
   }
 
   return;
 }

void QUESO::GslMatrix::fillWithBlocksHorizontally	(	unsigned int	rowId,
		unsigned int	colId,
		const std::vector< GslMatrix * > &	matrices,
		bool	checkForExactNumRowsMatching,
		bool	checkForExactNumColsMatching
	)

This function fills this matrix horizontally with const block.

Definition at line 1028 of file GslMatrix.C.

References QUESO::Matrix::m_env, numCols(), numRowsLocal(), UQ_FATAL_TEST_MACRO, and QUESO::BaseEnvironment::worldRank().

 {
   unsigned int sumNumCols = 0;
   for (unsigned int i = 0; i < matrices.size(); ++i) {
     UQ_FATAL_TEST_MACRO(this->numRowsLocal() < (initialTargetRowId + matrices[i]->numRowsLocal()),
                         m_env.worldRank(),
                         "GslMatrix::fillWithBlocksHorizontally()",
                         "too big number of rows");
     UQ_FATAL_TEST_MACRO(checkForExactNumRowsMatching && (this->numRowsLocal() != (initialTargetRowId + matrices[i]->numRowsLocal())),
                         m_env.worldRank(),
                         "GslMatrix::fillWithBlocksHorizontally()",
                         "inconsistent number of rows");
     sumNumCols += matrices[i]->numCols();
   }
   UQ_FATAL_TEST_MACRO(this->numCols() < (initialTargetColId + sumNumCols),
                       m_env.worldRank(),
                       "GslMatrix::fillWithBlocksHorizontally()",
                       "too big number of cols");
   UQ_FATAL_TEST_MACRO(checkForExactNumColsMatching && (this->numCols() != (initialTargetColId + sumNumCols)),
                       m_env.worldRank(),
                       "GslMatrix::fillWithBlocksHorizontally()",
                       "inconsistent number of cols");
 
   unsigned int cumulativeColId = 0;
   for (unsigned int i = 0; i < matrices.size(); ++i) {
     unsigned int nRows = matrices[i]->numRowsLocal();
     unsigned int nCols = matrices[i]->numCols();
     for (unsigned int rowId = 0; rowId < nRows; ++rowId) {
       for (unsigned int colId = 0; colId < nCols; ++colId) {
         (*this)(initialTargetRowId + rowId, initialTargetColId + cumulativeColId + colId) = (*(matrices[i]))(rowId,colId);
       }
     }
     cumulativeColId += nCols;
   }
 
   return;
 }

void QUESO::GslMatrix::fillWithBlocksVertically	(	unsigned int	rowId,
		unsigned int	colId,
		const std::vector< const GslMatrix * > &	matrices,
		bool	checkForExactNumRowsMatching,
		bool	checkForExactNumColsMatching
	)

This function fills this matrix vertically with const block matrices.

Definition at line 1072 of file GslMatrix.C.

References QUESO::Matrix::m_env, numCols(), numRowsLocal(), UQ_FATAL_TEST_MACRO, and QUESO::BaseEnvironment::worldRank().

 {
   unsigned int sumNumRows = 0;
   for (unsigned int i = 0; i < matrices.size(); ++i) {
     UQ_FATAL_TEST_MACRO(this->numCols() < (initialTargetColId + matrices[i]->numCols()),
                         m_env.worldRank(),
                         "GslMatrix::fillWithBlocksVertically(const)",
                         "too big number of cols");
     UQ_FATAL_TEST_MACRO(checkForExactNumColsMatching && (this->numCols() != (initialTargetColId + matrices[i]->numCols())),
                         m_env.worldRank(),
                         "GslMatrix::fillWithBlocksVertically(const)",
                         "inconsistent number of cols");
     sumNumRows += matrices[i]->numRowsLocal();
   }
   UQ_FATAL_TEST_MACRO(this->numRowsLocal() < (initialTargetRowId + sumNumRows),
                       m_env.worldRank(),
                       "GslMatrix::fillWithBlocksVertically(const)",
                       "too big number of rows");
   UQ_FATAL_TEST_MACRO(checkForExactNumRowsMatching && (this->numRowsLocal() != (initialTargetRowId + sumNumRows)),
                       m_env.worldRank(),
                       "GslMatrix::fillWithBlocksVertically(const)",
                       "inconsistent number of rows");
 
   unsigned int cumulativeRowId = 0;
   for (unsigned int i = 0; i < matrices.size(); ++i) {
     unsigned int nRows = matrices[i]->numRowsLocal();
     unsigned int nCols = matrices[i]->numCols();
     for (unsigned int rowId = 0; rowId < nRows; ++rowId) {
       for (unsigned int colId = 0; colId < nCols; ++colId) {
         (*this)(initialTargetRowId + cumulativeRowId + rowId, initialTargetColId + colId) = (*(matrices[i]))(rowId,colId);
       }
     }
     cumulativeRowId += nRows;
   }
 
   return;
 }

void QUESO::GslMatrix::fillWithBlocksVertically	(	unsigned int	rowId,
		unsigned int	colId,
		const std::vector< GslMatrix * > &	matrices,
		bool	checkForExactNumRowsMatching,
		bool	checkForExactNumColsMatching
	)

This function fills this matrix vertically with block matrices.

Definition at line 1116 of file GslMatrix.C.

References QUESO::Matrix::m_env, numCols(), numRowsLocal(), UQ_FATAL_TEST_MACRO, and QUESO::BaseEnvironment::worldRank().

 {
   unsigned int sumNumRows = 0;
   for (unsigned int i = 0; i < matrices.size(); ++i) {
     UQ_FATAL_TEST_MACRO(this->numCols() < (initialTargetColId + matrices[i]->numCols()),
                         m_env.worldRank(),
                         "GslMatrix::fillWithBlocksVertically()",
                         "too big number of cols");
     UQ_FATAL_TEST_MACRO(checkForExactNumColsMatching && (this->numCols() != (initialTargetColId + matrices[i]->numCols())),
                         m_env.worldRank(),
                         "GslMatrix::fillWithBlocksVertically()",
                         "inconsistent number of cols");
     sumNumRows += matrices[i]->numRowsLocal();
   }
   UQ_FATAL_TEST_MACRO(this->numRowsLocal() < (initialTargetRowId + sumNumRows),
                       m_env.worldRank(),
                       "GslMatrix::fillWithBlocksVertically()",
                       "too big number of rows");
   UQ_FATAL_TEST_MACRO(checkForExactNumRowsMatching && (this->numRowsLocal() != (initialTargetRowId + sumNumRows)),
                       m_env.worldRank(),
                       "GslMatrix::fillWithBlocksVertically()",
                       "inconsistent number of rows");
 
   unsigned int cumulativeRowId = 0;
   for (unsigned int i = 0; i < matrices.size(); ++i) {
     unsigned int nRows = matrices[i]->numRowsLocal();
     unsigned int nCols = matrices[i]->numCols();
     for (unsigned int rowId = 0; rowId < nRows; ++rowId) {
       for (unsigned int colId = 0; colId < nCols; ++colId) {
         (*this)(initialTargetRowId + cumulativeRowId + rowId, initialTargetColId + colId) = (*(matrices[i]))(rowId,colId);
       }
     }
     cumulativeRowId += nRows;
   }
 
   return;
 }

void QUESO::GslMatrix::fillWithTensorProduct	(	unsigned int	rowId,
		unsigned int	colId,
		const GslMatrix &	mat1,
		const GslMatrix &	mat2,
		bool	checkForExactNumRowsMatching,
		bool	checkForExactNumColsMatching
	)

This function calculates the tensor product of matrices mat1 and mat2 and stores it in this matrix.

Definition at line 1160 of file GslMatrix.C.

References QUESO::Matrix::m_env, numCols(), numRowsLocal(), UQ_FATAL_TEST_MACRO, and QUESO::BaseEnvironment::worldRank().

 {
   UQ_FATAL_TEST_MACRO(this->numRowsLocal() < (initialTargetRowId + (mat1.numRowsLocal() * mat2.numRowsLocal())),
                       m_env.worldRank(),
                       "GslMatrix::fillTensorProduct(mat and mat)",
                       "too big number of rows");
   UQ_FATAL_TEST_MACRO(checkForExactNumRowsMatching && (this->numRowsLocal() != (initialTargetRowId + (mat1.numRowsLocal() * mat2.numRowsLocal()))),
                       m_env.worldRank(),
                       "GslMatrix::fillTensorProduct(mat and mat)",
                       "inconsistent number of rows");
   UQ_FATAL_TEST_MACRO(this->numCols() < (initialTargetColId + (mat1.numCols() * mat2.numCols())),
                       m_env.worldRank(),
                       "GslMatrix::fillTensorProduct(mat and mat)",
                       "too big number of columns");
   UQ_FATAL_TEST_MACRO(checkForExactNumColsMatching && (this->numCols() != (initialTargetColId + (mat1.numCols() * mat2.numCols()))),
                       m_env.worldRank(),
                       "GslMatrix::fillTensorProduct(mat and mat)",
                       "inconsistent number of columns");
 
   for (unsigned int rowId1 = 0; rowId1 < mat1.numRowsLocal(); ++rowId1) {
     for (unsigned int colId1 = 0; colId1 < mat1.numCols(); ++colId1) {
       double multiplicativeFactor = mat1(rowId1,colId1);
       unsigned int targetRowId = rowId1 * mat2.numRowsLocal();
       unsigned int targetColId = colId1 * mat2.numCols();
       for (unsigned int rowId2 = 0; rowId2 < mat2.numRowsLocal(); ++rowId2) {
         for (unsigned int colId2 = 0; colId2 < mat2.numCols(); ++colId2) {
           (*this)(initialTargetRowId + targetRowId + rowId2, initialTargetColId + targetColId + colId2) = multiplicativeFactor * mat2(rowId2,colId2);
         }
       }
     }
   }
 
   return;
 }

void QUESO::GslMatrix::fillWithTensorProduct	(	unsigned int	rowId,
		unsigned int	colId,
		const GslMatrix &	mat1,
		const GslVector &	vec2,
		bool	checkForExactNumRowsMatching,
		bool	checkForExactNumColsMatching
	)

This function calculates the tensor product of matrix mat1 and vector vec2 and stores it in this matrix.

Definition at line 1202 of file GslMatrix.C.

References QUESO::Matrix::m_env, numCols(), numRowsLocal(), QUESO::GslVector::sizeLocal(), UQ_FATAL_TEST_MACRO, and QUESO::BaseEnvironment::worldRank().

 {
   UQ_FATAL_TEST_MACRO(this->numRowsLocal() < (initialTargetRowId + (mat1.numRowsLocal() * vec2.sizeLocal())),
                       m_env.worldRank(),
                       "GslMatrix::fillTensorProduct(mat and vec)",
                       "too big number of rows");
   UQ_FATAL_TEST_MACRO(checkForExactNumRowsMatching && (this->numRowsLocal() != (initialTargetRowId + (mat1.numRowsLocal() * vec2.sizeLocal()))),
                       m_env.worldRank(),
                       "GslMatrix::fillTensorProduct(mat and vec)",
                       "inconsistent number of rows");
   UQ_FATAL_TEST_MACRO(this->numCols() < (initialTargetColId + (mat1.numCols() * 1)),
                       m_env.worldRank(),
                       "GslMatrix::fillTensorProduct(mat and vec)",
                       "too big number of columns");
   UQ_FATAL_TEST_MACRO(checkForExactNumColsMatching && (this->numCols() != (initialTargetColId + (mat1.numCols() * 1))),
                       m_env.worldRank(),
                       "GslMatrix::fillTensorProduct(mat and vec)",
                       "inconsistent number of columns");
 
   for (unsigned int rowId1 = 0; rowId1 < mat1.numRowsLocal(); ++rowId1) {
     for (unsigned int colId1 = 0; colId1 < mat1.numCols(); ++colId1) {
       double multiplicativeFactor = mat1(rowId1,colId1);
       unsigned int targetRowId = rowId1 * vec2.sizeLocal();
       unsigned int targetColId = colId1 * 1;
       for (unsigned int rowId2 = 0; rowId2 < vec2.sizeLocal(); ++rowId2) {
         for (unsigned int colId2 = 0; colId2 < 1; ++colId2) {
           (*this)(initialTargetRowId + targetRowId + rowId2, initialTargetColId + targetColId + colId2) = multiplicativeFactor * vec2[rowId2];
         }
       }
     }
   }
 
 
   return;
 }

void QUESO::GslMatrix::fillWithTranspose	(	unsigned int	rowId,
		unsigned int	colId,
		const GslMatrix &	mat,
		bool	checkForExactNumRowsMatching,
		bool	checkForExactNumColsMatching
	)

This function stores the transpose of this matrix into this matrix.

Definition at line 1245 of file GslMatrix.C.

References QUESO::Matrix::m_env, numCols(), numRowsLocal(), UQ_FATAL_TEST_MACRO, and QUESO::BaseEnvironment::worldRank().

 {
   unsigned int nRows = mat.numRowsLocal();
   unsigned int nCols = mat.numCols();
   UQ_FATAL_TEST_MACRO(this->numRowsLocal() < (initialTargetRowId + nCols),
                       m_env.worldRank(),
                       "GslMatrix::fillWithTranspose()",
                       "too big number of rows");
   UQ_FATAL_TEST_MACRO(checkForExactNumRowsMatching && (this->numRowsLocal() != (initialTargetRowId + nCols)),
                       m_env.worldRank(),
                       "GslMatrix::fillWithTranspose()",
                       "inconsistent number of rows");
   UQ_FATAL_TEST_MACRO(this->numCols() < (initialTargetColId + nRows),
                       m_env.worldRank(),
                       "GslMatrix::fillWithTranspose()",
                       "too big number of cols");
   UQ_FATAL_TEST_MACRO(checkForExactNumColsMatching && (this->numCols() != (initialTargetColId + nRows)),
                       m_env.worldRank(),
                       "GslMatrix::fillWithTranspose()",
                       "inconsistent number of cols");
 
   for (unsigned int row = 0; row < nRows; ++row) {
     for (unsigned int col = 0; col < nCols; ++col) {
       (*this)(initialTargetRowId + col, initialTargetColId + row) = mat(row,col);
     }
   }
 
   return;
 }

void QUESO::GslMatrix::filterLargeValues ( double thresholdValue )

This function sets to zero (filters) all entries of this matrix which are greater than thresholdValue.

If thresholdValue < 0 then no values will be filtered.

Definition at line 801 of file GslMatrix.C.

References numCols(), and numRowsLocal().

 {
   unsigned int nRows = this->numRowsLocal();
   unsigned int nCols = this->numCols();
   for (unsigned int i = 0; i < nRows; ++i) {
     for (unsigned int j = 0; j < nCols; ++j) {
       double aux = (*this)(i,j);
       // If 'thresholdValue' is negative, no values will be filtered
       if ((aux             < 0. ) &&
           (-thresholdValue > aux)) {
         (*this)(i,j) = 0.;
       }
       if ((aux            > 0. ) &&
           (thresholdValue < aux)) {
         (*this)(i,j) = 0.;
       }
     }
   }
 
   return;
 }

void QUESO::GslMatrix::filterSmallValues ( double thresholdValue )

This function sets to zero (filters) all entries of this matrix which are smaller than thresholdValue.

If thresholdValue < 0 then no values will be filtered.

Definition at line 778 of file GslMatrix.C.

References numCols(), and numRowsLocal().

 {
   unsigned int nRows = this->numRowsLocal();
   unsigned int nCols = this->numCols();
   for (unsigned int i = 0; i < nRows; ++i) {
     for (unsigned int j = 0; j < nCols; ++j) {
       double aux = (*this)(i,j);
       // If 'thresholdValue' is negative, no values will be filtered
       if ((aux             < 0. ) &&
           (-thresholdValue < aux)) {
         (*this)(i,j) = 0.;
       }
       if ((aux            > 0. ) &&
           (thresholdValue > aux)) {
         (*this)(i,j) = 0.;
       }
     }
   }
 
   return;
 }

void QUESO::GslMatrix::getColumn	(	const unsigned int	column_num,
		GslVector &	column
	)		const

This function gets the column_num-th column of this matrix and stores it into vector column.

Definition at line 1880 of file GslMatrix.C.

References QUESO::Matrix::env(), QUESO::BaseEnvironment::fullRank(), m_mat, numCols(), numRowsLocal(), QUESO::GslVector::sizeLocal(), UQ_FATAL_RC_MACRO, and UQ_FATAL_TEST_MACRO.

Referenced by getColumn(), invertMultiply(), matlabLinearInterpExtrap(), and svdSolve().

 {
   // Sanity checks
   UQ_FATAL_TEST_MACRO(column_num >= this->numCols(),
                       env().fullRank(),
                       "GslMatrix::getColumn",
                       "Specified row number not within range");
 
   UQ_FATAL_TEST_MACRO((column.sizeLocal() != this->numRowsLocal()),
                       env().fullRank(),
                       "GslMatrix::getColumn",
                       "column vector not same size as this matrix");
 
   // Temporary working vector
   gsl_vector* gsl_column = gsl_vector_alloc( column.sizeLocal() );
 
   int error_code = gsl_matrix_get_col( gsl_column, m_mat, column_num );
   UQ_FATAL_RC_MACRO( (error_code != 0),
                      env().fullRank(),
                      "GslMatrix::getColumn()",
                      "gsl_matrix_get_col failed");
 
   // Copy column from gsl matrix into our GslVector object
   for( unsigned int i = 0; i < column.sizeLocal(); ++i )
     {
       column[i] = gsl_vector_get( gsl_column, i );
     }
 
   // Clean up gsl temporaries
   gsl_vector_free( gsl_column );
 
   return;
 }

GslVector QUESO::GslMatrix::getColumn ( const unsigned int column_num ) const

This function gets the column_num-th column of this matrix.

Definition at line 1963 of file GslMatrix.C.

References getColumn(), QUESO::Matrix::m_env, and QUESO::Matrix::m_map.

 {
   // We rely on the void getRow's to do sanity checks
   // So we don't do them here.
 
   GslVector column(m_env, m_map);
 
   this->getColumn( column_num, column );
 
   return column;
 }

void QUESO::GslMatrix::getRow	(	const unsigned int	row_num,
		GslVector &	row
	)		const

This function gets the row_num-th column of this matrix and stores it into vector row.

Definition at line 1915 of file GslMatrix.C.

References QUESO::Matrix::env(), QUESO::BaseEnvironment::fullRank(), m_mat, numCols(), numRowsLocal(), QUESO::GslVector::sizeLocal(), UQ_FATAL_RC_MACRO, and UQ_FATAL_TEST_MACRO.

Referenced by getRow().

 {
   // Sanity checks
   UQ_FATAL_TEST_MACRO(row_num >= this->numRowsLocal(),
                       env().fullRank(),
                       "GslMatrix::getRow",
                       "Specified row number not within range");
 
   UQ_FATAL_TEST_MACRO((row.sizeLocal() != this->numCols()),
                       env().fullRank(),
                       "GslMatrix::getRow",
                       "row vector not same size as this matrix");
 
   // Temporary working vector
   gsl_vector* gsl_row = gsl_vector_alloc( row.sizeLocal() );
 
   int error_code = gsl_matrix_get_row( gsl_row, m_mat, row_num );
   UQ_FATAL_RC_MACRO( (error_code != 0),
                      env().fullRank(),
                      "GslMatrix::getRow()",
                      "gsl_matrix_get_row failed");
 
   // Copy row from gsl matrix into our GslVector object
   for( unsigned int i = 0; i < row.sizeLocal(); ++i )
     {
       row[i] = gsl_vector_get( gsl_row, i );
     }
 
   // Clean up gsl temporaries
   gsl_vector_free( gsl_row );
 
   return;
 }

GslVector QUESO::GslMatrix::getRow ( const unsigned int row_num ) const

This function gets the row_num-th column of this matrix.

Definition at line 1950 of file GslMatrix.C.

References getRow(), QUESO::Matrix::m_env, and QUESO::Matrix::m_map.

 {
   // We rely on the void getRow's to do sanity checks
   // So we don't do them here.
 
   GslVector row(m_env, m_map);
 
   this->getRow( row_num, row );
 
   return row;
 }

int QUESO::GslMatrix::internalSvd ( ) const

private

This function factorizes the M-by-N matrix A into the singular value decomposition A = U S V^T for M >= N. On output the matrix A is replaced by U.

Definition at line 654 of file GslMatrix.C.

References QUESO::GslVector::data(), data(), GslMatrix(), QUESO::Matrix::m_env, m_svdColMap, m_svdSvec, m_svdUmat, m_svdVmat, m_svdVTmat, QUESO::Matrix::map(), numCols(), numRowsLocal(), transpose(), UQ_FATAL_TEST_MACRO, QUESO::UQ_MATRIX_SVD_FAILED_RC, UQ_RC_MACRO, and QUESO::BaseEnvironment::worldRank().

Referenced by rank(), svd(), svdMatU(), svdMatV(), and svdSolve().

 {
   int iRC = 0;
 
   if (m_svdColMap == NULL) {
     unsigned int nRows = this->numRowsLocal();
     unsigned int nCols = this->numCols();
     UQ_FATAL_TEST_MACRO(nRows < nCols,
                         m_env.worldRank(),
                         "GslMatrix::internalSvd()",
                         "GSL only supports cases where nRows >= nCols");
 
     m_svdColMap = new Map(this->numCols(),0,this->map().Comm()); // see 'VectorSpace<.,.>::newMap()' in src/basic/src/GslVectorSpace.C
     m_svdUmat   = new GslMatrix(*this); // Yes, 'this'
     m_svdSvec   = new GslVector(m_env,*m_svdColMap);
     m_svdVmat   = new GslMatrix(*m_svdSvec);
     m_svdVTmat  = new GslMatrix(*m_svdSvec);
 
     //std::cout << "In GslMatrix::internalSvd()"
     //          << ", calling gsl_linalg_SV_decomp_jacobi()..."
     //          << ": nRows = " << nRows
     //          << ", nCols = " << nCols
     //          << std::endl;
     struct timeval timevalBegin;
     gettimeofday(&timevalBegin, NULL);
     gsl_error_handler_t* oldHandler;
     oldHandler = gsl_set_error_handler_off();
 #if 1
     iRC = gsl_linalg_SV_decomp_jacobi(m_svdUmat->data(), m_svdVmat->data(), m_svdSvec->data());
 #else
     GslVector vecWork(*m_svdSvec );
     iRC = gsl_linalg_SV_decomp(m_svdUmat->data(), m_svdVmat->data(), m_svdSvec->data(), vecWork.data());
 #endif
     if (iRC != 0) {
       std::cerr << "In GslMatrix::internalSvd()"
                 << ": iRC = " << iRC
                 << ", gsl error message = " << gsl_strerror(iRC)
                 << std::endl;
     }
     gsl_set_error_handler(oldHandler);
 
     struct timeval timevalNow;
     gettimeofday(&timevalNow, NULL);
     //std::cout << "In GslMatrix::internalSvd()"
     //          << ": returned from gsl_linalg_SV_decomp_jacobi() with iRC = " << iRC
     //          << " after " << timevalNow.tv_sec - timevalBegin.tv_sec
     //          << " seconds"
     //          << std::endl;
     UQ_RC_MACRO(iRC, // Yes, *not* a fatal check on RC
                 m_env.worldRank(),
                 "GslMatrix::internalSvd()",
                 "matrix svd failed",
                 UQ_MATRIX_SVD_FAILED_RC);
     *m_svdVTmat = m_svdVmat->transpose();
   }
 
   return iRC;
 }

GslMatrix QUESO::GslMatrix::inverse ( ) const

This function calculated the inverse of this matrix (square).

Definition at line 845 of file GslMatrix.C.

References QUESO::BaseEnvironment::checkingLevel(), QUESO::GslVector::cwSet(), QUESO::BaseEnvironment::displayVerbosity(), GslMatrix(), invertMultiply(), lnDeterminant(), QUESO::Matrix::m_env, m_inverse, QUESO::Matrix::m_map, numCols(), numRowsLocal(), QUESO::BaseEnvironment::subDisplayFile(), UQ_FATAL_TEST_MACRO, and QUESO::BaseEnvironment::worldRank().

 {
   unsigned int nRows = this->numRowsLocal();
   unsigned int nCols = this->numCols();
 
   UQ_FATAL_TEST_MACRO((nRows != nCols),
                       m_env.worldRank(),
                       "GslMatrix::inverse()",
                       "matrix is not square");
 
   if (m_inverse == NULL) {
     m_inverse = new GslMatrix(m_env,m_map,nCols);
     GslVector unitVector(m_env,m_map);
     unitVector.cwSet(0.);
     GslVector multVector(m_env,m_map);
     for (unsigned int j = 0; j < nCols; ++j) {
       if (j > 0) unitVector[j-1] = 0.;
       unitVector[j] = 1.;
       this->invertMultiply(unitVector, multVector);
       for (unsigned int i = 0; i < nRows; ++i) {
         (*m_inverse)(i,j) = multVector[i];
       }
     }
   }
   if (m_env.checkingLevel() >= 1) {
     *m_env.subDisplayFile() << "CHECKING In GslMatrix::inverse()"
                             << ": M.lnDet = "      << this->lnDeterminant()
                             << ", M^{-1}.lnDet = " << m_inverse->lnDeterminant()
                             << std::endl;
   }
   if ((m_env.subDisplayFile()) && (m_env.displayVerbosity() >= 5)) {
     *m_env.subDisplayFile() << "In GslMatrix::inverse():"
                             << "\n M = "        << *this
                             << "\n M^{-1} = "   << *m_inverse
                             << "\n M*M^{-1} = " << (*this)*(*m_inverse)
                             << "\n M^{-1}*M = " << (*m_inverse)*(*this)
                             << std::endl;
   }
 
   return *m_inverse;
 }

GslVector QUESO::GslMatrix::invertMultiply ( const GslVector & b ) const

This function calculates the inverse of this matrix and multiplies it with vector b.

It calls void GslMatrix::invertMultiply(const GslVector& b, GslVector& x) internally.

Definition at line 1441 of file GslMatrix.C.

References QUESO::Matrix::m_env, QUESO::Matrix::m_map, numCols(), QUESO::GslVector::sizeLocal(), UQ_FATAL_TEST_MACRO, and QUESO::BaseEnvironment::worldRank().

Referenced by determinant(), inverse(), invertMultiply(), and lnDeterminant().

 {
   UQ_FATAL_TEST_MACRO((this->numCols() != b.sizeLocal()),
                       m_env.worldRank(),
                       "GslMatrix::invertMultiply(), return vector",
                       "matrix and rhs have incompatible sizes");
 
   GslVector x(m_env,m_map);
   this->invertMultiply(b,x);
 
   return x;
 }

void QUESO::GslMatrix::invertMultiply	(	const GslVector &	b,
		GslVector &	x
	)		const

This function calculates the inverse of this matrix, multiplies it with vector b and stores the result in vector x.

It checks for a previous LU decomposition of this matrix and does not recompute it if m_MU != NULL .

Definition at line 1456 of file GslMatrix.C.

References QUESO::GslVector::data(), QUESO::BaseEnvironment::displayVerbosity(), QUESO::Matrix::m_env, QUESO::Matrix::m_inDebugMode, m_isSingular, m_LU, m_mat, m_permutation, m_signum, QUESO::GslVector::norm2(), numCols(), numRowsLocal(), QUESO::GslVector::sizeLocal(), QUESO::BaseEnvironment::subDisplayFile(), UQ_FATAL_RC_MACRO, UQ_FATAL_TEST_MACRO, and QUESO::BaseEnvironment::worldRank().

 {
   UQ_FATAL_TEST_MACRO((this->numCols() != b.sizeLocal()),
                       m_env.worldRank(),
                       "GslMatrix::invertMultiply(), return void",
                       "matrix and rhs have incompatible sizes");
 
   UQ_FATAL_TEST_MACRO((x.sizeLocal() != b.sizeLocal()),
                       m_env.worldRank(),
                       "GslMatrix::invertMultiply(), return void",
                       "solution and rhs have incompatible sizes");
 
   int iRC;
   if (m_LU == NULL) {
     UQ_FATAL_TEST_MACRO((m_permutation != NULL),
                         m_env.worldRank(),
                         "GslMatrix::invertMultiply()",
                         "m_permutation should be NULL");
 
     m_LU = gsl_matrix_calloc(this->numRowsLocal(),this->numCols());
     UQ_FATAL_TEST_MACRO((m_LU == NULL),
                         m_env.worldRank(),
                         "GslMatrix::invertMultiply()",
                         "gsl_matrix_calloc() failed");
 
     iRC = gsl_matrix_memcpy(m_LU, m_mat);
     UQ_FATAL_RC_MACRO(iRC,
                       m_env.worldRank(),
                       "GslMatrix::invertMultiply()",
                       "gsl_matrix_memcpy() failed");
 
     m_permutation = gsl_permutation_calloc(numCols());
     UQ_FATAL_TEST_MACRO((m_permutation == NULL),
                         m_env.worldRank(),
                         "GslMatrix::invertMultiply()",
                         "gsl_permutation_calloc() failed");
 
     if (m_inDebugMode) {
       std::cout << "In GslMatrix::invertMultiply()"
                 << ": before LU decomposition, m_LU = ";
       gsl_matrix_fprintf(stdout, m_LU, "%f");
       std::cout << std::endl;
     }
 
     gsl_error_handler_t* oldHandler;
     oldHandler = gsl_set_error_handler_off();
     if ((m_env.subDisplayFile()) && (m_env.displayVerbosity() >= 99)) {
       *m_env.subDisplayFile() << "In GslMatrix::invertMultiply()"
                               << ": before 'gsl_linalg_LU_decomp()'"
                               << std::endl;
     }
     iRC = gsl_linalg_LU_decomp(m_LU,m_permutation,&m_signum);
     if (iRC != 0) {
       std::cerr << "In GslMatrix::invertMultiply()"
                 << ", after gsl_linalg_LU_decomp()"
                 << ": iRC = " << iRC
                 << ", gsl error message = " << gsl_strerror(iRC)
                 << std::endl;
     }
     gsl_set_error_handler(oldHandler);
     if ((m_env.subDisplayFile()) && (m_env.displayVerbosity() >= 99)) {
       *m_env.subDisplayFile() << "In GslMatrix::invertMultiply()"
                               << ": after 'gsl_linalg_LU_decomp()'"
                               << ", IRC = " << iRC
                               << std::endl;
     }
     UQ_FATAL_RC_MACRO(iRC,
                       m_env.worldRank(),
                       "GslMatrix::invertMultiply()",
                       "gsl_linalg_LU_decomp() failed");
 
     if (m_inDebugMode) {
       std::cout << "In GslMatrix::invertMultiply()"
                 << ": after LU decomposition, m_LU = ";
       gsl_matrix_fprintf(stdout, m_LU, "%f");
       std::cout << std::endl;
     }
   }
 
   gsl_error_handler_t* oldHandler;
   oldHandler = gsl_set_error_handler_off();
   if ((m_env.subDisplayFile()) && (m_env.displayVerbosity() >= 99)) {
     *m_env.subDisplayFile() << "In GslMatrix::invertMultiply()"
                             << ": before 'gsl_linalg_LU_solve()'"
                             << std::endl;
   }
   iRC = gsl_linalg_LU_solve(m_LU,m_permutation,b.data(),x.data());
   if (iRC != 0) {
     m_isSingular = true;
     std::cerr << "In GslMatrix::invertMultiply()"
               << ", after gsl_linalg_LU_solve()"
               << ": iRC = " << iRC
               << ", gsl error message = " << gsl_strerror(iRC)
               << std::endl;
   }
   gsl_set_error_handler(oldHandler);
   if ((m_env.subDisplayFile()) && (m_env.displayVerbosity() >= 99)) {
     *m_env.subDisplayFile() << "In GslMatrix::invertMultiply()"
                             << ": after 'gsl_linalg_LU_solve()'"
                             << ", IRC = " << iRC
                             << std::endl;
   }
   // prudenci, 2012-09-26: commented the 'UQ_FATAL_RC_MACRO' below
   //UQ_FATAL_RC_MACRO(iRC,
   //                  m_env.worldRank(),
   //                  "GslMatrix::invertMultiply()",
   //                  "gsl_linalg_LU_solve() failed");
 
   if (m_inDebugMode) {
     GslVector tmpVec(b - (*this)*x);
     std::cout << "In GslMatrix::invertMultiply()"
               << ": ||b - Ax||_2 = "         << tmpVec.norm2()
               << ": ||b - Ax||_2/||b||_2 = " << tmpVec.norm2()/b.norm2()
               << std::endl;
   }
 
   return;
 }

GslMatrix QUESO::GslMatrix::invertMultiply ( const GslMatrix & B ) const

This function calculates the inverse of this matrix and multiplies it with matrix B.

It calls void GslMatrix::invertMultiply(const GslMatrix& B, GslMatrix& X) const internally.

Definition at line 1578 of file GslMatrix.C.

References invertMultiply(), QUESO::Matrix::m_env, QUESO::Matrix::m_map, and numCols().

 {
   GslMatrix X(m_env,m_map,B.numCols());
   this->invertMultiply(B,X);
 
   return X;
 }

void QUESO::GslMatrix::invertMultiply	(	const GslMatrix &	B,
		GslMatrix &	X
	)		const

This function calculates the inverse of this matrix, multiplies it with matrix B and stores the result in matrix X.

It checks for a previous LU decomposition of this matrix and does not recompute it if m_MU != NULL .

Definition at line 1587 of file GslMatrix.C.

References getColumn(), invertMultiply(), QUESO::Matrix::m_env, QUESO::Matrix::m_map, numCols(), numRowsLocal(), setColumn(), UQ_FATAL_RC_MACRO, and QUESO::BaseEnvironment::worldRank().

 {
 
   // Sanity Checks
   UQ_FATAL_RC_MACRO(((B.numRowsLocal() != X.numRowsLocal()) ||
                      (B.numCols()      != X.numCols()     )),
                     m_env.worldRank(),
                     "GslMatrix::invertMultiply()",
                     "Matrices B and X are incompatible");
 
 
   UQ_FATAL_RC_MACRO((this->numRowsLocal() != X.numRowsLocal()),
                     m_env.worldRank(),
                     "GslMatrix::invertMultiply()",
                     "This and X matrices are incompatible");
 
   // Some local variables used within the loop.
   GslVector b(m_env, m_map);
   GslVector x(m_env, m_map);
 
   for( unsigned int j = 0; j < B.numCols(); ++j )
     {
       b = B.getColumn( j );
 
       //invertMultiply will only do the LU once and store it. So we don't
       //need to worry about it doing LU multiple times.
       x = this->invertMultiply( b );
 
       X.setColumn( j, x );
     }
 
   return;
 }

GslVector QUESO::GslMatrix::invertMultiplyForceLU ( const GslVector & b ) const

This function calculates the inverse of this matrix and multiplies it with vector b.

  It calls void GslMatrix::InvertMultiplyForceLU(const GslVector& b, GslVector& x) const;(const GslVector& b,

GslVector& x) internally.

Definition at line 1622 of file GslMatrix.C.

References QUESO::Matrix::m_env, QUESO::Matrix::m_map, numCols(), QUESO::GslVector::sizeLocal(), UQ_FATAL_TEST_MACRO, and QUESO::BaseEnvironment::worldRank().

 {
   UQ_FATAL_TEST_MACRO((this->numCols() != b.sizeLocal()),
                       m_env.worldRank(),
                       "GslMatrix::invertMultiply(), return vector",
                       "matrix and rhs have incompatible sizes");
 
   GslVector x(m_env,m_map);
   this->invertMultiplyForceLU(b,x);
 
   return x;
 }

void QUESO::GslMatrix::invertMultiplyForceLU	(	const GslVector &	b,
		GslVector &	x
	)		const

This function calculates the inverse of this matrix, multiplies it with vector b and stores the result in vector x.

It recalculates the LU decomposition of this matrix.

Definition at line 1637 of file GslMatrix.C.

References QUESO::GslVector::data(), QUESO::Matrix::m_env, m_isSingular, m_LU, m_mat, m_permutation, m_signum, numCols(), numRowsLocal(), QUESO::GslVector::sizeLocal(), UQ_FATAL_RC_MACRO, UQ_FATAL_TEST_MACRO, and QUESO::BaseEnvironment::worldRank().

 {
   UQ_FATAL_TEST_MACRO((this->numCols() != b.sizeLocal()),
                       m_env.worldRank(),
                       "GslMatrix::invertMultiplyForceLU(), return void",
                       "matrix and rhs have incompatible sizes");
 
   UQ_FATAL_TEST_MACRO((x.sizeLocal() != b.sizeLocal()),
                       m_env.worldRank(),
                       "GslMatrix::invertMultiplyForceLU(), return void",
                       "solution and rhs have incompatible sizes");
 
   int iRC;
 
   if ( m_LU == NULL ) {
     UQ_FATAL_TEST_MACRO((m_permutation != NULL),
                         m_env.worldRank(),
                         "GslMatrix::invertMultiplyForceLU()",
                         "m_permutation should be NULL");
     m_LU = gsl_matrix_calloc(this->numRowsLocal(),this->numCols());
   }
   UQ_FATAL_TEST_MACRO((m_LU == NULL),
                       m_env.worldRank(),
                       "GslMatrix::invertMultiplyForceLU()",
                       "gsl_matrix_calloc() failed");
 
   iRC = gsl_matrix_memcpy(m_LU, m_mat);
   UQ_FATAL_RC_MACRO(iRC,
                     m_env.worldRank(),
                     "GslMatrix::invertMultiplyForceLU()",
                     "gsl_matrix_memcpy() failed");
 
   if( m_permutation == NULL ) m_permutation = gsl_permutation_calloc(numCols());
   UQ_FATAL_TEST_MACRO((m_permutation == NULL),
                       m_env.worldRank(),
                       "GslMatrix::invertMultiplyForceLU()",
                       "gsl_permutation_calloc() failed");
 
   iRC = gsl_linalg_LU_decomp(m_LU,m_permutation,&m_signum);
   UQ_FATAL_RC_MACRO(iRC,
                     m_env.worldRank(),
                     "GslMatrix::invertMultiplyForceLU()",
                     "gsl_linalg_LU_decomp() failed");
 
   iRC = gsl_linalg_LU_solve(m_LU,m_permutation,b.data(),x.data());
   if (iRC != 0) {
     m_isSingular = true;
   }
   UQ_FATAL_RC_MACRO(iRC,
                     m_env.worldRank(),
                     "GslMatrix::invertMultiplyForceLU()",
                     "gsl_linalg_LU_solve() failed");
 
   return;
 }

void QUESO::GslMatrix::largestEigen	(	double &	eigenValue,
		GslVector &	eigenVector
	)		const

This function finds largest eigenvalue, namely eigenValue, of this matrix and its corresponding eigenvector, namely eigenVector.

Definition at line 1728 of file GslMatrix.C.

References QUESO::GslVector::abs(), QUESO::Matrix::env(), QUESO::Matrix::m_env, QUESO::Matrix::m_map, QUESO::GslVector::sizeLocal(), and UQ_FATAL_TEST_MACRO.

 {
 
   // Sanity Checks
   unsigned int n = eigenVector.sizeLocal();
 
   UQ_FATAL_TEST_MACRO((n == 0),
                       env().fullRank(),
                       "GslMatrix::largestEigen()",
                       "invalid input vector size");
 
   /* The following notation is used:
      z = vector used in iteration that ends up being the eigenvector corresponding to the
          largest eigenvalue
      w = vector used in iteration that we extract the largest eigenvalue from.  */
 
   // Some parameters associated with the algorithm
   // TODO: Do we want to add the ability to have these set by the user?
   const unsigned int max_num_iterations = 10000;
   const double tolerance = 1.0e-13;
 
   // Create temporary working vectors.
   // TODO: We shouldn't have to use these - we ought to be able to work directly
   // TODO: with eigenValue and eigenVector. Optimize this once we have regression
   // TODO: tests.
   GslVector z(m_env, m_map, 1.0 ); // Needs to be initialized to 1.0
   GslVector w(m_env, m_map);
 
   // Some variables we use inside the loop.
   int index;
   double residual;
   double lambda;
 
   for( unsigned int k = 0; k < max_num_iterations; ++k )
     {
       w = (*this) * z;
 
       // For this algorithm, it's crucial to get the maximum in
       // absolute value, but then to normalize by the actual value
       // and *not* the absolute value.
       index = (w.abs()).getMaxValueIndex();
 
       lambda = w[index];
 
       z = (1.0/lambda) * w;
 
       // Here we use the norm of the residual as our convergence check:
       // norm( A*x - \lambda*x )
       residual = ( (*this)*z - lambda*z ).norm2();
 
       if( residual < tolerance )
         {
           eigenValue = lambda;
 
           // TODO: Do we want to normalize this so eigenVector.norm2() = 1?
           eigenVector = z;
           return;
         }
 
     }
 
   // If we reach this point, then we didn't converge. Print error message
   // to this effect.
   // TODO: We know we failed at this point - need a way to not need a test
   // TODO: Just specify the error.
   UQ_FATAL_TEST_MACRO((residual >= tolerance),
                       env().fullRank(),
                       "GslMatrix::largestEigen()",
                       "Maximum num iterations exceeded");
 
 
   return;
 }

double QUESO::GslMatrix::lnDeterminant ( ) const

Calculates the ln(determinant) of this matrix.

Definition at line 1322 of file GslMatrix.C.

References QUESO::BaseEnvironment::displayVerbosity(), invertMultiply(), m_determinant, QUESO::Matrix::m_env, m_lnDeterminant, m_LU, QUESO::Matrix::m_map, m_signum, and QUESO::BaseEnvironment::subDisplayFile().

Referenced by inverse().

 {
   if (m_lnDeterminant == -INFINITY) {
     if (m_LU == NULL) {
       GslVector tmpB(m_env,m_map);
       GslVector tmpX(m_env,m_map);
       if ((m_env.subDisplayFile()) && (m_env.displayVerbosity() >= 99)) {
         *m_env.subDisplayFile() << "In GslMatrix::lnDeterminant()"
                                 << ": before 'this->invertMultiply()'"
                                 << std::endl;
       }
       this->invertMultiply(tmpB,tmpX);
       if ((m_env.subDisplayFile()) && (m_env.displayVerbosity() >= 99)) {
         *m_env.subDisplayFile() << "In GslMatrix::lnDeterminant()"
                                 << ": after 'this->invertMultiply()'"
                                 << std::endl;
       }
     }
     if ((m_env.subDisplayFile()) && (m_env.displayVerbosity() >= 99)) {
       *m_env.subDisplayFile() << "In GslMatrix::lnDeterminant()"
                               << ": before 'gsl_linalg_LU_det()'"
                               << std::endl;
     }
     m_determinant   = gsl_linalg_LU_det(m_LU,m_signum);
     if ((m_env.subDisplayFile()) && (m_env.displayVerbosity() >= 99)) {
       *m_env.subDisplayFile() << "In GslMatrix::lnDeterminant()"
                               << ": after 'gsl_linalg_LU_det()'"
                               << std::endl;
     }
     m_lnDeterminant = gsl_linalg_LU_lndet(m_LU);
     if ((m_env.subDisplayFile()) && (m_env.displayVerbosity() >= 99)) {
       *m_env.subDisplayFile() << "In GslMatrix::lnDeterminant()"
                               << ": before 'gsl_linalg_LU_lndet()'"
                               << std::endl;
     }
   }
 
   return m_lnDeterminant;
 }

void QUESO::GslMatrix::matlabLinearInterpExtrap	(	const GslVector &	x1Vec,
		const GslMatrix &	y1Mat,
		const GslVector &	x2Vec
	)

Definition at line 2071 of file GslMatrix.C.

References getColumn(), QUESO::Matrix::m_env, QUESO::GslVector::matlabLinearInterpExtrap(), numCols(), numRowsLocal(), setColumn(), QUESO::GslVector::sizeLocal(), UQ_FATAL_TEST_MACRO, and QUESO::BaseEnvironment::worldRank().

 {
   UQ_FATAL_TEST_MACRO(x1Vec.sizeLocal() <= 1,
                       m_env.worldRank(),
                       "GslMatrix::matlabLinearInterpExtrap()",
                       "invalid 'x1' size");
 
   UQ_FATAL_TEST_MACRO(x1Vec.sizeLocal() != y1Mat.numRowsLocal(),
                       m_env.worldRank(),
                       "GslMatrix::matlabLinearInterpExtrap()",
                       "invalid 'x1' and 'y1' sizes");
 
   UQ_FATAL_TEST_MACRO(x2Vec.sizeLocal() != this->numRowsLocal(),
                       m_env.worldRank(),
                       "GslMatrix::matlabLinearInterpExtrap()",
                       "invalid 'x2' and 'this' sizes");
 
   UQ_FATAL_TEST_MACRO(y1Mat.numCols() != this->numCols(),
                       m_env.worldRank(),
                       "GslMatrix::matlabLinearInterpExtrap()",
                       "invalid 'y1' and 'this' sizes");
 
   GslVector y1Vec(x1Vec);
   GslVector y2Vec(x2Vec);
   for (unsigned int colId = 0; colId < y1Mat.numCols(); ++colId) {
     y1Mat.getColumn(colId,y1Vec);
     y2Vec.matlabLinearInterpExtrap(x1Vec,y1Vec,x2Vec);
     this->setColumn(colId,y2Vec);
   }
 
   return;
 }

double QUESO::GslMatrix::max ( ) const

Returns the maximum element value of the matrix.

Definition at line 403 of file GslMatrix.C.

References numCols(), and numRowsLocal().

 {
   double value = -INFINITY;
 
   unsigned int nRows = this->numRowsLocal();
   unsigned int nCols = this->numCols();
   double aux = 0.;
   for (unsigned int i = 0; i < nRows; i++) {
     for (unsigned int j = 0; j < nCols; j++) {
       aux = (*this)(i,j);
       if (aux > value) value = aux;
     }
   }
 
   return value;
 }

void QUESO::GslMatrix::mpiSum	(	const MpiComm &	comm,
		GslMatrix &	M_global
	)		const

Definition at line 2028 of file GslMatrix.C.

References QUESO::MpiComm::Allreduce(), QUESO::Matrix::env(), QUESO::BaseEnvironment::fullRank(), numCols(), numRowsLocal(), RawValue_MPI_DOUBLE, RawValue_MPI_SUM, and UQ_FATAL_RC_MACRO.

 {
   // Sanity Checks
   UQ_FATAL_RC_MACRO(((this->numRowsLocal() != M_global.numRowsLocal()) ||
                      (this->numCols()      != M_global.numCols()     )),
                     env().fullRank(),
                     "GslMatrix::mpiSum()",
                     "local and global matrices incompatible");
 
   /* TODO: Probably a better way to handle this unpacking/packing of data */
   int size = M_global.numRowsLocal()*M_global.numCols();
   std::vector<double> local( size, 0.0 );
   std::vector<double> global( size, 0.0 );
 
   int k;
   for( unsigned int i = 0; i < this->numRowsLocal(); i++ )
     {
       for( unsigned int j = 0; j < this->numCols(); j++ )
         {
           k = i + j*M_global.numCols();
 
           local[k] = (*this)(i,j);
         }
     }
 
   comm.Allreduce((void*) &local[0], (void*) &global[0], size, RawValue_MPI_DOUBLE, RawValue_MPI_SUM,
                  "GslMatrix::mpiSum()",
                  "failed MPI.Allreduce()");
 
   for( unsigned int i = 0; i < this->numRowsLocal(); i++ )
     {
       for( unsigned int j = 0; j < this->numCols(); j++ )
         {
           k = i + j*M_global.numCols();
 
           M_global(i,j) = global[k];
         }
     }
 
   return;
 }

GslVector QUESO::GslMatrix::multiply ( const GslVector & x ) const

This function multiplies this matrix by vector x and returns the resulting vector.

Definition at line 1398 of file GslMatrix.C.

References QUESO::Matrix::m_env, QUESO::Matrix::m_map, numCols(), QUESO::GslVector::sizeLocal(), UQ_FATAL_TEST_MACRO, and QUESO::BaseEnvironment::worldRank().

Referenced by QUESO::operator*().

 {
   UQ_FATAL_TEST_MACRO((this->numCols() != x.sizeLocal()),
                       m_env.worldRank(),
                       "GslMatrix::multiply(), return vector",
                       "matrix and vector have incompatible sizes");
 
   GslVector y(m_env,m_map);
   this->multiply(x,y);
 
   return y;
 }

void QUESO::GslMatrix::multiply	(	const GslVector &	x,
		GslVector &	y
	)		const

private

This function multiplies this matrix by vector x and stores the resulting vector in y.

Definition at line 1413 of file GslMatrix.C.

References QUESO::Matrix::m_env, numCols(), numRowsLocal(), QUESO::GslVector::sizeLocal(), UQ_FATAL_TEST_MACRO, and QUESO::BaseEnvironment::worldRank().

 {
   UQ_FATAL_TEST_MACRO((this->numCols() != x.sizeLocal()),
                       m_env.worldRank(),
                       "GslMatrix::multiply(), vector return void",
                       "matrix and x have incompatible sizes");
 
   UQ_FATAL_TEST_MACRO((this->numRowsLocal() != y.sizeLocal()),
                       m_env.worldRank(),
                       "GslMatrix::multiply(), vector return void",
                       "matrix and y have incompatible sizes");
 
   unsigned int sizeX = this->numCols();
   unsigned int sizeY = this->numRowsLocal();
   for (unsigned int i = 0; i < sizeY; ++i) {
     double value = 0.;
     for (unsigned int j = 0; j < sizeX; ++j) {
       value += (*this)(i,j)*x[j];
     }
     y[i] = value;
   }
 
   return;
 }

double QUESO::GslMatrix::normFrob ( ) const

Returns the Frobenius norm of this matrix.

Definition at line 367 of file GslMatrix.C.

References numCols(), and numRowsLocal().

 {
   double value = 0.;
 
   unsigned int nRows = this->numRowsLocal();
   unsigned int nCols = this->numCols();
   double aux = 0.;
   for (unsigned int i = 0; i < nRows; i++) {
     for (unsigned int j = 0; j < nCols; j++) {
       aux = (*this)(i,j);
       value += aux*aux;
     }
   }
 
   return sqrt(value);
 }

double QUESO::GslMatrix::normMax ( ) const

Returns the Frobenius norm of this matrix.

Definition at line 385 of file GslMatrix.C.

References numCols(), and numRowsLocal().

 {
   double value = 0.;
 
   unsigned int nRows = this->numRowsLocal();
   unsigned int nCols = this->numCols();
   double aux = 0.;
   for (unsigned int i = 0; i < nRows; i++) {
     for (unsigned int j = 0; j < nCols; j++) {
       aux = fabs((*this)(i,j));
       if (aux > value) value = aux;
     }
   }
 
   return value;
 }

unsigned int QUESO::GslMatrix::numCols ( ) const

virtual

Returns the column dimension of this matrix.

Implements QUESO::Matrix.

Definition at line 361 of file GslMatrix.C.

References m_mat.

Referenced by cwExtract(), cwSet(), fillWithBlocksDiagonally(), fillWithBlocksHorizontally(), fillWithBlocksVertically(), fillWithTensorProduct(), fillWithTranspose(), filterLargeValues(), filterSmallValues(), getColumn(), getRow(), internalSvd(), inverse(), invertMultiply(), invertMultiplyForceLU(), QUESO::leftDiagScaling(), matlabLinearInterpExtrap(), max(), mpiSum(), multiply(), normFrob(), normMax(), QUESO::operator*(), print(), rank(), QUESO::rightDiagScaling(), setColumn(), setRow(), subReadContents(), subWriteContents(), svd(), svdSolve(), transpose(), zeroLower(), and zeroUpper().

 {
   return m_mat->size2;
 }

unsigned int QUESO::GslMatrix::numRowsGlobal ( ) const

virtual

Returns the global row dimension of this matrix.

Implements QUESO::Matrix.

Definition at line 355 of file GslMatrix.C.

References m_mat.

 {
   return m_mat->size1;
 }

unsigned int QUESO::GslMatrix::numRowsLocal ( ) const

virtual

Returns the local row dimension of this matrix.

Implements QUESO::Matrix.

Definition at line 349 of file GslMatrix.C.

References m_mat.

Referenced by cwExtract(), cwSet(), eigen(), fillWithBlocksDiagonally(), fillWithBlocksHorizontally(), fillWithBlocksVertically(), fillWithTensorProduct(), fillWithTranspose(), filterLargeValues(), filterSmallValues(), QUESO::GaussianLikelihoodBlockDiagonalCovariance< V, M >::GaussianLikelihoodBlockDiagonalCovariance(), QUESO::GaussianLikelihoodBlockDiagonalCovarianceRandomCoefficients< V, M >::GaussianLikelihoodBlockDiagonalCovarianceRandomCoefficients(), getColumn(), getRow(), internalSvd(), inverse(), invertMultiply(), invertMultiplyForceLU(), QUESO::leftDiagScaling(), matlabLinearInterpExtrap(), max(), mpiSum(), multiply(), normFrob(), normMax(), QUESO::operator*(), print(), rank(), QUESO::rightDiagScaling(), setColumn(), setRow(), subReadContents(), subWriteContents(), svd(), svdSolve(), transpose(), zeroLower(), and zeroUpper().

 {
   return m_mat->size1;
 }

double & QUESO::GslMatrix::operator()	(	unsigned int	i,
		unsigned int	j
	)

Element access method (non-const).

Definition at line 254 of file GslMatrix.C.

References QUESO::Matrix::m_env, m_mat, resetLU(), UQ_FATAL_TEST_MACRO, and QUESO::BaseEnvironment::worldRank().

 {
   this->resetLU();
   if ((i >= m_mat->size1) ||
       (j >= m_mat->size2)) {
     std::cerr << "In GslMatrix::operator(i,j)"
               << ": i = " << i
               << ", j = " << j
               << ", m_mat->size1 = " << m_mat->size1
               << ", m_mat->size2 = " << m_mat->size2
               << std::endl;
     UQ_FATAL_TEST_MACRO(i >= m_mat->size1,
                         m_env.worldRank(),
                         "GslMatrix::operator(i,j)",
                         "i is too large");
     UQ_FATAL_TEST_MACRO(j >= m_mat->size2,
                         m_env.worldRank(),
                         "GslMatrix::operator(i,j)",
                         "j is too large");
   }
   return *gsl_matrix_ptr(m_mat,i,j);
 }

const double & QUESO::GslMatrix::operator()	(	unsigned int	i,
		unsigned int	j
	)		const

Element access method (const).

Definition at line 278 of file GslMatrix.C.

References QUESO::Matrix::m_env, m_mat, UQ_FATAL_TEST_MACRO, and QUESO::BaseEnvironment::worldRank().

 {
   UQ_FATAL_TEST_MACRO(i >= m_mat->size1,
                       m_env.worldRank(),
                       "GslMatrix::operator(i,j) const",
                       "i is too large");
   UQ_FATAL_TEST_MACRO(j >= m_mat->size2,
                       m_env.worldRank(),
                       "GslMatrix::operator(i,j) const",
                       "j is too large");
   return *gsl_matrix_const_ptr(m_mat,i,j);
 }

GslMatrix & QUESO::GslMatrix::operator*= ( double a )

Stores in this the coordinate-wise multiplication of this and a.

Definition at line 203 of file GslMatrix.C.

References QUESO::Matrix::m_env, m_mat, resetLU(), UQ_FATAL_RC_MACRO, and QUESO::BaseEnvironment::worldRank().

 {
   this->resetLU();
   int iRC;
   iRC = gsl_matrix_scale(m_mat,a);
   UQ_FATAL_RC_MACRO(iRC,
                     m_env.worldRank(),
                     "GslMatrix::operator*=()",
                     "scaling failed");
   return *this;
 }

GslMatrix & QUESO::GslMatrix::operator+= ( const GslMatrix & rhs )

Stores in this the coordinate-wise addition of this and rhs.

Definition at line 225 of file GslMatrix.C.

References QUESO::Matrix::m_env, m_mat, resetLU(), UQ_FATAL_RC_MACRO, and QUESO::BaseEnvironment::worldRank().

 {
   this->resetLU();
   int iRC;
   iRC = gsl_matrix_add(m_mat,rhs.m_mat);
   UQ_FATAL_RC_MACRO(iRC,
                     m_env.worldRank(),
                     "GslMatrix::operator+=()",
                     "failed");
 
   return *this;
 }

GslMatrix & QUESO::GslMatrix::operator-= ( const GslMatrix & rhs )

Stores in this the coordinate-wise subtraction of this by rhs.

Definition at line 239 of file GslMatrix.C.

References QUESO::Matrix::m_env, m_mat, resetLU(), UQ_FATAL_RC_MACRO, and QUESO::BaseEnvironment::worldRank().

 {
   this->resetLU();
   int iRC;
   iRC = gsl_matrix_sub(m_mat,rhs.m_mat);
   UQ_FATAL_RC_MACRO(iRC,
                     m_env.worldRank(),
                     "GslMatrix::operator-=()",
                     "failed");
 
   return *this;
 }

GslMatrix & QUESO::GslMatrix::operator/= ( double a )

Stores in this the coordinate-wise division of this by a.

Definition at line 216 of file GslMatrix.C.

References resetLU().

 {
   this->resetLU();
   *this *= (1./a);
 
   return *this;
 }

GslMatrix & QUESO::GslMatrix::operator= ( const GslMatrix & rhs )

Copies values from matrix rhs to this.

Definition at line 195 of file GslMatrix.C.

References copy(), and resetLU().

 {
   this->resetLU();
   this->copy(obj);
   return *this;
 }

void QUESO::GslMatrix::print ( std::ostream & os ) const

virtual

Print method. Defines the behavior of the ostream << operator inherited from the Object class.

Implements QUESO::Matrix.

Definition at line 2114 of file GslMatrix.C.

References QUESO::Matrix::m_printHorizontally, numCols(), and numRowsLocal().

Referenced by QUESO::operator<<(), and QUESO::GslBlockMatrix::print().

 {
   unsigned int nRows = this->numRowsLocal();
   unsigned int nCols = this->numCols();
 
   if (m_printHorizontally) {
     for (unsigned int i = 0; i < nRows; ++i) {
       for (unsigned int j = 0; j < nCols; ++j) {
         os << (*this)(i,j)
            << " ";
       }
       if (i != (nRows-1)) os << "; ";
     }
     //os << std::endl;
   }
   else {
     for (unsigned int i = 0; i < nRows; ++i) {
       for (unsigned int j = 0; j < nCols; ++j) {
         os << (*this)(i,j)
            << " ";
       }
       os << std::endl;
     }
   }
 
   return;
 }

unsigned int QUESO::GslMatrix::rank	(	double	absoluteZeroThreshold,
		double	relativeZeroThreshold
	)		const

This function returns the number of singular values of this matrix (rank).

The rank function provides an estimate of the number of linearly independent rows or columns of a full matrix.

Definition at line 1363 of file GslMatrix.C.

References QUESO::BaseEnvironment::displayVerbosity(), internalSvd(), QUESO::Matrix::m_env, m_svdSvec, numCols(), numRowsLocal(), QUESO::GslVector::sizeLocal(), and QUESO::BaseEnvironment::subDisplayFile().

 {
   int iRC = 0;
   iRC = internalSvd();
   if (iRC) {}; // just to remove compiler warning
 
   GslVector relativeVec(*m_svdSvec);
   if (relativeVec[0] > 0.) {
     relativeVec = (1./relativeVec[0])*relativeVec;
   }
 
   unsigned int rankValue = 0;
   for (unsigned int i = 0; i < relativeVec.sizeLocal(); ++i) {
     if (( (*m_svdSvec)[i] >= absoluteZeroThreshold ) &&
         ( relativeVec [i] >= relativeZeroThreshold )) {
        rankValue += 1;
     }
   }
 
   if ((m_env.subDisplayFile()) && (m_env.displayVerbosity() >= 3)) {
     *m_env.subDisplayFile() << "In GslMatrix::rank()"
                             << ": this->numRowsLocal() = "  << this->numRowsLocal()
                             << ", this->numCols() = "       << this->numCols()
                             << ", absoluteZeroThreshold = " << absoluteZeroThreshold
                             << ", relativeZeroThreshold = " << relativeZeroThreshold
                             << ", rankValue = "             << rankValue
                             << ", m_svdSvec = "             << *m_svdSvec
                             << ", relativeVec = "           << relativeVec
                             << std::endl;
   }
 
   return rankValue;
 }

void QUESO::GslMatrix::resetLU ( )

private

In this function resets the LU decomposition of this matrix, as well as deletes the private member pointers, if existing.

Definition at line 306 of file GslMatrix.C.

References m_determinant, m_inverse, m_isSingular, m_lnDeterminant, m_LU, m_permutation, m_signum, m_svdColMap, m_svdSvec, m_svdUmat, m_svdVmat, and m_svdVTmat.

Referenced by copy(), operator()(), operator*=(), operator+=(), operator-=(), operator/=(), operator=(), setColumn(), setRow(), zeroLower(), zeroUpper(), and ~GslMatrix().

 {
   if (m_LU) {
     gsl_matrix_free(m_LU);
     m_LU = NULL;
   }
   if (m_inverse) {
     delete m_inverse;
     m_inverse = NULL;
   }
   if (m_svdColMap) {
     delete m_svdColMap;
     m_svdColMap = NULL;
   }
   if (m_svdUmat) {
     delete m_svdUmat;
     m_svdUmat = NULL;
   }
   if (m_svdSvec) {
     delete m_svdSvec;
     m_svdSvec = NULL;
   }
   if (m_svdVmat) {
     delete m_svdVmat;
     m_svdVmat = NULL;
   }
   if (m_svdVTmat) {
     delete m_svdVTmat;
     m_svdVTmat = NULL;
   }
   m_determinant   = -INFINITY;
   m_lnDeterminant = -INFINITY;
   if (m_permutation) {
     gsl_permutation_free(m_permutation);
     m_permutation = NULL;
   }
   m_signum = 0;
   m_isSingular = false;
 
   return;
 }

void QUESO::GslMatrix::setColumn	(	const unsigned int	column_num,
		const GslVector &	column
	)

This function copies vector column into the column_num-th column of this matrix.

Definition at line 2002 of file GslMatrix.C.

References QUESO::GslVector::data(), QUESO::Matrix::env(), QUESO::BaseEnvironment::fullRank(), m_mat, numCols(), numRowsLocal(), resetLU(), QUESO::GslVector::sizeLocal(), UQ_FATAL_RC_MACRO, and UQ_FATAL_TEST_MACRO.

Referenced by invertMultiply(), matlabLinearInterpExtrap(), and svdSolve().

 {
   this->resetLU();
   // Sanity checks
   UQ_FATAL_TEST_MACRO(column_num >= this->numCols(),
                       env().fullRank(),
                       "GslMatrix::setColumn",
                       "Specified column number not within range");
 
   UQ_FATAL_TEST_MACRO((column.sizeLocal() != this->numRowsLocal()),
                       env().fullRank(),
                       "GslMatrix::setColumn",
                       "column vector not same size as this matrix");
 
   gsl_vector* gsl_column = column.data();
 
   int error_code = gsl_matrix_set_col( m_mat, column_num, gsl_column );
   UQ_FATAL_RC_MACRO( (error_code != 0),
                      env().fullRank(),
                      "GslMatrix::setColumn()",
                      "gsl_matrix_set_col failed");
 
   return;
 }

void QUESO::GslMatrix::setRow	(	const unsigned int	row_num,
		const GslVector &	row
	)

This function copies vector row into the row_num-th column of this matrix.

Definition at line 1976 of file GslMatrix.C.

References QUESO::GslVector::data(), QUESO::Matrix::env(), QUESO::BaseEnvironment::fullRank(), m_mat, numCols(), numRowsLocal(), resetLU(), QUESO::GslVector::sizeLocal(), UQ_FATAL_RC_MACRO, and UQ_FATAL_TEST_MACRO.

 {
   this->resetLU();
   // Sanity checks
   UQ_FATAL_TEST_MACRO(row_num >= this->numRowsLocal(),
                       env().fullRank(),
                       "GslMatrix::setRow",
                       "Specified row number not within range");
 
   UQ_FATAL_TEST_MACRO((row.sizeLocal() != this->numCols()),
                       env().fullRank(),
                       "GslMatrix::setRow",
                       "row vector not same size as this matrix");
 
   gsl_vector* gsl_row = row.data();
 
   int error_code = gsl_matrix_set_row( m_mat, row_num, gsl_row );
   UQ_FATAL_RC_MACRO( (error_code != 0),
                      env().fullRank(),
                      "GslMatrix::setRow()",
                      "gsl_matrix_set_row failed");
 
   return;
 }

void QUESO::GslMatrix::smallestEigen	(	double &	eigenValue,
		GslVector &	eigenVector
	)		const

This function finds smallest eigenvalue, namely eigenValue, of this matrix and its corresponding eigenvector, namely eigenVector.

Definition at line 1803 of file GslMatrix.C.

References QUESO::GslVector::abs(), QUESO::Matrix::env(), QUESO::Matrix::m_env, QUESO::Matrix::m_map, QUESO::GslVector::sizeLocal(), and UQ_FATAL_TEST_MACRO.

 {
   // Sanity Checks
   unsigned int n = eigenVector.sizeLocal();
 
   UQ_FATAL_TEST_MACRO((n == 0),
                       env().fullRank(),
                       "GslMatrix::smallestEigen()",
                       "invalid input vector size");
 
   /* The following notation is used:
      z = vector used in iteration that ends up being the eigenvector corresponding to the
          largest eigenvalue
      w = vector used in iteration that we extract the largest eigenvalue from.  */
 
   // Some parameters associated with the algorithm
   // TODO: Do we want to add the ability to have these set by the user?
   const unsigned int max_num_iterations = 1000;
   const double tolerance = 1.0e-13;
 
   // Create temporary working vectors.
   // TODO: We shouldn't have to use these - we ought to be able to work directly
   // TODO: with eigenValue and eigenVector. Optimize this once we have regression
   // TODO: tests.
   GslVector z(m_env, m_map, 1.0 ); // Needs to be initialized to 1.0
   GslVector w(m_env, m_map);
 
   // Some variables we use inside the loop.
   int index;
   double residual;
   double one_over_lambda;
   double lambda;
 
   for( unsigned int k = 0; k < max_num_iterations; ++k )
     {
       w = (*this).invertMultiplyForceLU( z );
 
       // For this algorithm, it's crucial to get the maximum in
       // absolute value, but then to normalize by the actual value
       // and *not* the absolute value.
       index = (w.abs()).getMaxValueIndex();
 
       // Remember: Inverse power method solves for max 1/lambda ==> lambda smallest
       one_over_lambda = w[index];
 
       lambda = 1.0/one_over_lambda;
 
       z = lambda * w;
 
       // Here we use the norm of the residual as our convergence check:
       // norm( A*x - \lambda*x )
       residual = ( (*this)*z - lambda*z ).norm2();
 
       if( residual < tolerance )
         {
           eigenValue = lambda;
 
           // TODO: Do we want to normalize this so eigenVector.norm2() = 1?
           eigenVector = z;
           return;
         }
 
     }
 
   // If we reach this point, then we didn't converge. Print error message
   // to this effect.
   // TODO: We know we failed at this point - need a way to not need a test
   // TODO: Just specify the error.
   UQ_FATAL_TEST_MACRO((residual >= tolerance),
                       env().fullRank(),
                       "GslMatrix::smallestEigen()",
                       "Maximum num iterations exceeded");
 
   return;
 }

void QUESO::GslMatrix::subReadContents	(	const std::string &	fileName,
		const std::string &	fileType,
		const std::set< unsigned int > &	allowedSubEnvIds
	)

Read contents of subenvironment from file fileName.

Definition at line 2189 of file GslMatrix.C.

References QUESO::BaseEnvironment::closeFile(), QUESO::BaseEnvironment::fullRank(), QUESO::Matrix::m_env, numCols(), QUESO::Matrix::numOfProcsForStorage(), numRowsLocal(), QUESO::BaseEnvironment::openInputFile(), QUESO::BaseEnvironment::subDisplayFile(), QUESO::BaseEnvironment::subRank(), UQ_FATAL_TEST_MACRO, and QUESO::BaseEnvironment::worldRank().

 {
   UQ_FATAL_TEST_MACRO(m_env.subRank() < 0,
                       m_env.worldRank(),
                       "GslMatrix::subReadContents()",
                       "unexpected subRank");
 
   UQ_FATAL_TEST_MACRO(this->numOfProcsForStorage() > 1,
                       m_env.worldRank(),
                       "GslMatrix::subReadContents()",
                       "implemented just for sequential vectors for now");
 
   FilePtrSetStruct filePtrSet;
   if (m_env.openInputFile(fileName,
                           fileType, // "m or hdf"
                           allowedSubEnvIds,
                           filePtrSet)) {
 
     // palms
     unsigned int nRowsLocal = this->numRowsLocal();
 
     // In the logic below, the id of a line' begins with value 0 (zero)
     unsigned int idOfMyFirstLine = 1;
     unsigned int idOfMyLastLine = nRowsLocal;
     unsigned int nCols = this->numCols();
 
     // Read number of matrix rows in the file by taking care of the first line,
     // which resembles something like 'variable_name = zeros(n_rows,n_cols);'
     std::string tmpString;
 
     // Read 'variable name' string
     *filePtrSet.ifsVar >> tmpString;
     //std::cout << "Just read '" << tmpString << "'" << std::endl;
 
     // Read '=' sign
     *filePtrSet.ifsVar >> tmpString;
     //std::cout << "Just read '" << tmpString << "'" << std::endl;
     UQ_FATAL_TEST_MACRO(tmpString != "=",
                         m_env.worldRank(),
                         "GslMatrix::subReadContents()",
                         "string should be the '=' sign");
 
     // Read 'zeros(n_rows,n_cols)' string
     *filePtrSet.ifsVar >> tmpString;
     //std::cout << "Just read '" << tmpString << "'" << std::endl;
     unsigned int posInTmpString = 6;
 
     // Isolate 'n_rows' in a string
     char nRowsString[tmpString.size()-posInTmpString+1];
     unsigned int posInRowsString = 0;
     do {
       UQ_FATAL_TEST_MACRO(posInTmpString >= tmpString.size(),
                           m_env.worldRank(),
                           "GslMatrix::subReadContents()",
                           "symbol ',' not found in first line of file");
       nRowsString[posInRowsString++] = tmpString[posInTmpString++];
     } while (tmpString[posInTmpString] != ',');
     nRowsString[posInRowsString] = '\0';
 
     // Isolate 'n_cols' in a string
     posInTmpString++; // Avoid reading ',' char
     char nColsString[tmpString.size()-posInTmpString+1];
     unsigned int posInColsString = 0;
     do {
       UQ_FATAL_TEST_MACRO(posInTmpString >= tmpString.size(),
                           m_env.worldRank(),
                           "GslMatrix::subReadContents()",
                           "symbol ')' not found in first line of file");
       nColsString[posInColsString++] = tmpString[posInTmpString++];
     } while (tmpString[posInTmpString] != ')');
     nColsString[posInColsString] = '\0';
 
     // Convert 'n_rows' and 'n_cols' strings to numbers
     unsigned int numRowsInFile = (unsigned int) strtod(nRowsString,NULL);
     unsigned int numColsInFile = (unsigned int) strtod(nColsString,NULL);
     if (m_env.subDisplayFile()) {
       *m_env.subDisplayFile() << "In GslMatrix::subReadContents()"
                               << ": fullRank "        << m_env.fullRank()
                               << ", numRowsInFile = " << numRowsInFile
                               << ", numColsInFile = " << numColsInFile
                               << ", nRowsLocal = "    << nRowsLocal
                               << ", nCols = "         << nCols
                               << std::endl;
     }
 
     // Check if [num of rows in file] == [requested matrix row size]
     UQ_FATAL_TEST_MACRO(numRowsInFile != nRowsLocal,
                         m_env.worldRank(),
                         "GslMatrix::subReadContents()",
                         "size of vec in file is not big enough");
 
     // Check if [num of cols in file] == [num cols in current matrix]
     UQ_FATAL_TEST_MACRO(numColsInFile != nCols,
                         m_env.worldRank(),
                         "GslMatrix::subReadContents()",
                         "number of parameters of vec in file is different than number of parameters in this vec object");
 
     // Code common to any core in a communicator
     unsigned int maxCharsPerLine = 64*nCols; // Up to about 60 characters to represent each parameter value
 
     unsigned int lineId = 0;
     while (lineId < idOfMyFirstLine) {
       filePtrSet.ifsVar->ignore(maxCharsPerLine,'\n');
       lineId++;
     };
 
     if (m_env.subDisplayFile()) {
       *m_env.subDisplayFile() << "In GslMatrix::subReadContents()"
                               << ": beginning to read input actual data"
                               << std::endl;
     }
 
     // Take care of initial part of the first data line,
     // which resembles something like 'variable_name = [value1 value2 ...'
     // Read 'variable name' string
     *filePtrSet.ifsVar >> tmpString;
     //std::cout << "Core 0 just read '" << tmpString << "'" << std::endl;
 
     // Read '=' sign
     *filePtrSet.ifsVar >> tmpString;
     //std::cout << "Core 0 just read '" << tmpString << "'" << std::endl;
     UQ_FATAL_TEST_MACRO(tmpString != "=",
                         m_env.worldRank(),
                         "GslMatrix::subReadContents()",
                         "in core 0, string should be the '=' sign");
 
     // Take into account the ' [' portion
     std::streampos tmpPos = filePtrSet.ifsVar->tellg();
     filePtrSet.ifsVar->seekg(tmpPos+(std::streampos)2);
 
     if (m_env.subDisplayFile()) {
       *m_env.subDisplayFile() << "In GslMatrix::subReadContents()"
                               << ": beginning to read lines with numbers only"
                               << ", lineId = "          << lineId
                               << ", idOfMyFirstLine = " << idOfMyFirstLine
                               << ", idOfMyLastLine = "  << idOfMyLastLine
                               << std::endl;
     }
 
     double tmpRead;
     while (lineId <= idOfMyLastLine) {
       for (unsigned int j = 0; j < nCols; ++j) {
         *filePtrSet.ifsVar >> tmpRead;
         (*this)(lineId-idOfMyFirstLine,j) = tmpRead;
       }
       lineId++;
     };
 
     m_env.closeFile(filePtrSet,fileType);
   }
 
   return;
 }

void QUESO::GslMatrix::subWriteContents	(	const std::string &	varNamePrefix,
		const std::string &	fileName,
		const std::string &	fileType,
		const std::set< unsigned int > &	allowedSubEnvIds
	)		const

Write contents of subenvironment in file fileName.

Definition at line 2143 of file GslMatrix.C.

References QUESO::BaseEnvironment::closeFile(), QUESO::Matrix::m_env, numCols(), QUESO::Matrix::numOfProcsForStorage(), numRowsLocal(), QUESO::BaseEnvironment::openOutputFile(), QUESO::BaseEnvironment::subIdString(), QUESO::BaseEnvironment::subRank(), UQ_FATAL_TEST_MACRO, and QUESO::BaseEnvironment::worldRank().

 {
   UQ_FATAL_TEST_MACRO(m_env.subRank() < 0,
                       m_env.worldRank(),
                       "GslMatrix::subWriteContents()",
                       "unexpected subRank");
 
   UQ_FATAL_TEST_MACRO(this->numOfProcsForStorage() > 1,
                       m_env.worldRank(),
                       "GslMatrix::subWriteContents()",
                       "implemented just for sequential vectors for now");
 
   FilePtrSetStruct filePtrSet;
   if (m_env.openOutputFile(fileName,
                            fileType, // "m or hdf"
                            allowedSubEnvIds,
                            false,
                            filePtrSet)) {
     unsigned int nRows = this->numRowsLocal();
     unsigned int nCols = this->numCols();
     *filePtrSet.ofsVar << varNamePrefix << "_sub" << m_env.subIdString() << " = zeros(" << nRows
                        << ","                                                           << nCols
                        << ");"
                        << std::endl;
     *filePtrSet.ofsVar << varNamePrefix << "_sub" << m_env.subIdString() << " = [";
 
     for (unsigned int i = 0; i < nRows; ++i) {
       for (unsigned int j = 0; j < nCols; ++j) {
         *filePtrSet.ofsVar << (*this)(i,j)
                 << " ";
       }
       *filePtrSet.ofsVar << "\n";
     }
     *filePtrSet.ofsVar << "];\n";
 
     m_env.closeFile(filePtrSet,fileType);
   }
 
   return;
 }

int QUESO::GslMatrix::svd	(	GslMatrix &	matU,
		GslVector &	vecS,
		GslMatrix &	matVt
	)		const

Checks for the dimension of this matrix, matU, VecS and matVt, and calls the protected routine internalSvd to compute the singular values of this.

Definition at line 533 of file GslMatrix.C.

References internalSvd(), QUESO::Matrix::m_env, m_svdSvec, m_svdUmat, m_svdVTmat, numCols(), numRowsLocal(), QUESO::GslVector::sizeLocal(), UQ_FATAL_TEST_MACRO, and QUESO::BaseEnvironment::worldRank().

 {
   unsigned int nRows = this->numRowsLocal();
   unsigned int nCols = this->numCols();
 
   UQ_FATAL_TEST_MACRO((matU.numRowsLocal() != nRows) || (matU.numCols() != nCols),
                       m_env.worldRank(),
                       "GslMatrix::svd()",
                       "invalid matU");
 
   UQ_FATAL_TEST_MACRO((vecS.sizeLocal() != nCols), //std::min(nRows,nRows)),
                       m_env.worldRank(),
                       "GslMatrix::svd()",
                       "invalid vecS");
 
   UQ_FATAL_TEST_MACRO((matVt.numRowsLocal() != nCols) || (matVt.numCols() != nCols),
                       m_env.worldRank(),
                       "GslMatrix::svd()",
                       "invalid matVt");
 
   int iRC = internalSvd();
 
   matU  = *m_svdUmat;
   vecS  = *m_svdSvec;
   matVt = *m_svdVTmat;
 
   return iRC;
 }

const GslMatrix & QUESO::GslMatrix::svdMatU ( ) const

This function calls private member GslMatrix::internalSvd() to set a M-by-N orthogonal matrix U of the singular value decomposition (svd) of a general rectangular M-by-N matrix A.

A general rectangular M-by-N matrix A has a singular value decomposition (svd) into the product of an M-by-N orthogonal matrix U, an N-by-N diagonal matrix of singular values S and the transpose of an N-by-N orthogonal square matrix V, A = U S V^T.

Definition at line 634 of file GslMatrix.C.

References internalSvd(), and m_svdUmat.

 {
   int iRC = 0;
   iRC = internalSvd();
   if (iRC) {}; // just to remove compiler warning
 
   return *m_svdUmat;
 }

const GslMatrix & QUESO::GslMatrix::svdMatV ( ) const

This function calls private member GslMatrix::internalSvd() to set a N-by-N orthogonal square matrix V of the singular value decomposition (svd) of a general rectangular M-by-N matrix A.

A general rectangular M-by-N matrix A has a singular value decomposition (svd) into the product of an M-by-N orthogonal matrix U, an N-by-N diagonal matrix of singular values S and the transpose of an N-by-N orthogonal square matrix V, A = U S V^T.

Definition at line 644 of file GslMatrix.C.

References internalSvd(), and m_svdVmat.

 {
   int iRC = 0;
   iRC = internalSvd();
   if (iRC) {}; // just to remove compiler warning
 
   return *m_svdVmat;
 }

int QUESO::GslMatrix::svdSolve	(	const GslVector &	rhsVec,
		GslVector &	solVec
	)		const

This function solves the system A x = b using the singular value decomposition (U, S, V) of A which must have been computed previously with GslMatrix::svd (x=solVec, b=rhsVec).

Definition at line 563 of file GslMatrix.C.

References QUESO::GslVector::data(), data(), QUESO::BaseEnvironment::displayVerbosity(), internalSvd(), QUESO::Matrix::m_env, m_svdSvec, m_svdUmat, m_svdVmat, numCols(), numRowsLocal(), QUESO::GslVector::sizeLocal(), QUESO::BaseEnvironment::subDisplayFile(), UQ_FATAL_TEST_MACRO, and QUESO::BaseEnvironment::worldRank().

Referenced by svdSolve().

 {
   unsigned int nRows = this->numRowsLocal();
   unsigned int nCols = this->numCols();
 
   UQ_FATAL_TEST_MACRO((rhsVec.sizeLocal() != nRows),
                       m_env.worldRank(),
                       "GslMatrix::svdSolve()",
                       "invalid rhsVec");
 
   UQ_FATAL_TEST_MACRO((solVec.sizeLocal() != nCols),
                       m_env.worldRank(),
                       "GslMatrix::svdSolve()",
                       "invalid solVec");
 
   int iRC = internalSvd();
 
   if ((m_env.subDisplayFile()) && (m_env.displayVerbosity() >= 5)) {
     *m_env.subDisplayFile() << "In GslMatrix::svdSolve():"
                             << "\n this->numRowsLocal()      = " << this->numRowsLocal()
                             << ", this->numCols()      = "       << this->numCols()
                             << "\n m_svdUmat->numRowsLocal() = " << m_svdUmat->numRowsLocal()
                             << ", m_svdUmat->numCols() = "       << m_svdUmat->numCols()
                             << "\n m_svdVmat->numRowsLocal() = " << m_svdVmat->numRowsLocal()
                             << ", m_svdVmat->numCols() = "       << m_svdVmat->numCols()
                             << "\n m_svdSvec->sizeLocal()    = " << m_svdSvec->sizeLocal()
                             << "\n rhsVec.sizeLocal()        = " << rhsVec.sizeLocal()
                             << "\n solVec.sizeLocal()        = " << solVec.sizeLocal()
                             << std::endl;
   }
 
   if (iRC == 0) iRC = gsl_linalg_SV_solve(m_svdUmat->data(), m_svdVmat->data(), m_svdSvec->data(), rhsVec.data(), solVec.data());
 
   return iRC;
 }

int QUESO::GslMatrix::svdSolve	(	const GslMatrix &	rhsMat,
		GslMatrix &	solMat
	)		const

This function solves the system A x = b using the singular value decomposition (U, S, V) of A which must have been computed previously with GslMatrix::svd (x=solMat, b=rhsMat).

Definition at line 600 of file GslMatrix.C.

References getColumn(), QUESO::Matrix::m_env, QUESO::Matrix::map(), numCols(), numRowsLocal(), setColumn(), svdSolve(), UQ_FATAL_TEST_MACRO, and QUESO::BaseEnvironment::worldRank().

 {
   unsigned int nRows = this->numRowsLocal();
   unsigned int nCols = this->numCols();
 
   UQ_FATAL_TEST_MACRO((rhsMat.numRowsLocal() != nRows),
                       m_env.worldRank(),
                       "GslMatrix::svdSolve()",
                       "invalid rhsMat");
 
   UQ_FATAL_TEST_MACRO((solMat.numRowsLocal() != nCols),
                       m_env.worldRank(),
                       "GslMatrix::svdSolve()",
                       "invalid solMat");
 
   UQ_FATAL_TEST_MACRO((rhsMat.numCols() != solMat.numCols()),
                       m_env.worldRank(),
                       "GslMatrix::svdSolve()",
                       "rhsMat and solMat are not compatible");
 
   GslVector rhsVec(m_env,rhsMat.map());
   GslVector solVec(m_env,solMat.map());
   int iRC = 0;
   for (unsigned int j = 0; j < rhsMat.numCols(); ++j) {
     rhsVec = rhsMat.getColumn(j);
     iRC = this->svdSolve(rhsVec, solVec);
     if (iRC) break;
     solMat.setColumn(j,solVec);
   }
 
   return iRC;
 }

GslMatrix QUESO::GslMatrix::transpose ( ) const

This function calculated the transpose of this matrix (square).

Definition at line 824 of file GslMatrix.C.

References QUESO::Matrix::m_env, QUESO::Matrix::m_map, numCols(), numRowsLocal(), UQ_FATAL_TEST_MACRO, and QUESO::BaseEnvironment::worldRank().

Referenced by internalSvd().

 {
   unsigned int nRows = this->numRowsLocal();
   unsigned int nCols = this->numCols();
 
   UQ_FATAL_TEST_MACRO((nRows != nCols),
                       m_env.worldRank(),
                       "GslMatrix::transpose()",
                       "routine works only for square matrices");
 
   GslMatrix mat(m_env,m_map,nCols);
   for (unsigned int row = 0; row < nRows; ++row) {
     for (unsigned int col = 0; col < nCols; ++col) {
       mat(row,col) = (*this)(col,row);
     }
   }
 
   return mat;
 }

void QUESO::GslMatrix::zeroLower ( bool includeDiagonal = false )

virtual

This function sets all the entries bellow the main diagonal of this matrix to zero.

If \c includeDiagonal = false, then only the entries bellow the main diagonal are set to zero;

if includeDiagonal = true, then the elements of the matrix diagonal are also set to zero.

Implements QUESO::Matrix.

Definition at line 716 of file GslMatrix.C.

References QUESO::Matrix::m_env, numCols(), numRowsLocal(), resetLU(), UQ_FATAL_TEST_MACRO, and QUESO::BaseEnvironment::worldRank().

 {
   unsigned int nRows = this->numRowsLocal();
   unsigned int nCols = this->numCols();
 
   UQ_FATAL_TEST_MACRO((nRows != nCols),
                       m_env.worldRank(),
                       "GslMatrix::zeroLower()",
                       "routine works only for square matrices");
 
   this->resetLU();
 
   if (includeDiagonal) {
     for (unsigned int i = 0; i < nRows; i++) {
       for (unsigned int j = 0; j <= i; j++) {
         (*this)(i,j) = 0.;
       }
     }
   }
   else {
     for (unsigned int i = 0; i < nRows; i++) {
       for (unsigned int j = 0; j < i; j++) {
         (*this)(i,j) = 0.;
       }
     }
   }
 
   return;
 }

void QUESO::GslMatrix::zeroUpper ( bool includeDiagonal = false )

virtual

This function sets all the entries above the main diagonal of this matrix to zero.

If \c includeDiagonal = false, then only the entries above the main diagonal are set to zero;

if includeDiagonal = true, then the elements of the matrix diagonal are also set to zero.

Implements QUESO::Matrix.

Definition at line 747 of file GslMatrix.C.

References QUESO::Matrix::m_env, numCols(), numRowsLocal(), resetLU(), UQ_FATAL_TEST_MACRO, and QUESO::BaseEnvironment::worldRank().

 {
   unsigned int nRows = this->numRowsLocal();
   unsigned int nCols = this->numCols();
 
   UQ_FATAL_TEST_MACRO((nRows != nCols),
                       m_env.worldRank(),
                       "GslMatrix::zeroUpper()",
                       "routine works only for square matrices");
 
   this->resetLU();
 
   if (includeDiagonal) {
     for (unsigned int i = 0; i < nRows; i++) {
       for (unsigned int j = i; j < nCols; j++) {
         (*this)(i,j) = 0.;
       }
     }
   }
   else {
     for (unsigned int i = 0; i < nRows; i++) {
       for (unsigned int j = (i+1); j < nCols; j++) {
         (*this)(i,j) = 0.;
       }
     }
   }
 
   return;
 }

Member Data Documentation

double QUESO::GslMatrix::m_determinant

mutableprivate

The determinant of this matrix.

Definition at line 423 of file GslMatrix.h.

Referenced by determinant(), lnDeterminant(), and resetLU().

GslMatrix* QUESO::GslMatrix::m_inverse

mutableprivate

Inverse matrix of this.

Definition at line 392 of file GslMatrix.h.

Referenced by inverse(), and resetLU().

bool QUESO::GslMatrix::m_isSingular

mutableprivate

Indicates whether or not this matrix is singular.

Definition at line 441 of file GslMatrix.h.

Referenced by invertMultiply(), invertMultiplyForceLU(), and resetLU().

double QUESO::GslMatrix::m_lnDeterminant

mutableprivate

The natural logarithm of the determinant of this matrix.

Definition at line 426 of file GslMatrix.h.

Referenced by determinant(), lnDeterminant(), and resetLU().

gsl_matrix* QUESO::GslMatrix::m_LU

mutableprivate

GSL matrix for the LU decomposition of m_mat.

Definition at line 389 of file GslMatrix.h.

Referenced by determinant(), invertMultiply(), invertMultiplyForceLU(), lnDeterminant(), and resetLU().

gsl_matrix* QUESO::GslMatrix::m_mat

private

GSL matrix, also referred to as this matrix.

Definition at line 386 of file GslMatrix.h.

Referenced by chol(), copy(), cwSet(), data(), eigen(), getColumn(), getRow(), GslMatrix(), invertMultiply(), invertMultiplyForceLU(), numCols(), numRowsGlobal(), numRowsLocal(), operator()(), operator*=(), operator+=(), operator-=(), setColumn(), setRow(), and ~GslMatrix().

gsl_permutation* QUESO::GslMatrix::m_permutation

mutableprivate

The permutation matrix of a LU decomposition.

In the LU decomposition PA = LU, the j-th column of the matrix P is given by the k-th column of the identity matrix, where k = p_j the j-th element of the permutation vector. A is the square matrix of interest and P is the permutation matrix.

Definition at line 432 of file GslMatrix.h.

Referenced by invertMultiply(), invertMultiplyForceLU(), and resetLU().

int QUESO::GslMatrix::m_signum

mutableprivate

m_signum stores the sign of the permutation of the LU decomposition PA = LU.

In the LU decomposition PA = LU, where A is the square matrix of interest and P is the permutation matrix, m_signum has the value (-1)^n, where n is the number of interchanges in the permutation.

Definition at line 438 of file GslMatrix.h.

Referenced by determinant(), invertMultiply(), invertMultiplyForceLU(), lnDeterminant(), and resetLU().

Map* QUESO::GslMatrix::m_svdColMap

mutableprivate

Mapping for matrices involved in the singular value decomposition (svd) routine.

Definition at line 395 of file GslMatrix.h.

Referenced by internalSvd(), and resetLU().

GslVector* QUESO::GslMatrix::m_svdSvec

mutableprivate

m_svdSvec stores the diagonal of the N-by-N diagonal matrix of singular values S after the singular value decomposition of a matrix.

A general rectangular M-by-N matrix A has a singular value decomposition (svd) into the product of an M-by-N orthogonal matrix U, an N-by-N diagonal matrix of singular values S and the transpose of an N-by-N orthogonal square matrix V, A = U S V^T.

Definition at line 408 of file GslMatrix.h.

Referenced by internalSvd(), rank(), resetLU(), svd(), and svdSolve().

GslMatrix* QUESO::GslMatrix::m_svdUmat

mutableprivate

m_svdUmat stores the M-by-N orthogonal matrix U after the singular value decomposition of a matrix.

A general rectangular M-by-N matrix A has a singular value decomposition (svd) into the product of an M-by-N orthogonal matrix U, an N-by-N diagonal matrix of singular values S and the transpose of an N-by-N orthogonal square matrix V, A = U S V^T.

Definition at line 401 of file GslMatrix.h.

Referenced by internalSvd(), resetLU(), svd(), svdMatU(), and svdSolve().

GslMatrix* QUESO::GslMatrix::m_svdVmat

mutableprivate

m_svdVmat stores the N-by-N orthogonal square matrix V after the singular value decomposition of a matrix.

A general rectangular M-by-N matrix A has a singular value decomposition (svd) into the product of an M-by-N orthogonal matrix U, an N-by-N diagonal matrix of singular values S and the transpose of an N-by-N orthogonal square matrix V, A = U S V^T.

Definition at line 414 of file GslMatrix.h.

Referenced by internalSvd(), resetLU(), svdMatV(), and svdSolve().

GslMatrix* QUESO::GslMatrix::m_svdVTmat

mutableprivate

m_svdVmatT stores the transpose of N-by-N orthogonal square matrix V, namely V^T, after the singular value decomposition of a matrix.

A general rectangular M-by-N matrix A has a singular value decomposition (svd) into the product of an M-by-N orthogonal matrix U, an N-by-N diagonal matrix of singular values S and the transpose of an N-by-N orthogonal square matrix V, A = U S V^T.

Definition at line 420 of file GslMatrix.h.

Referenced by internalSvd(), resetLU(), and svd().

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

src/core/inc/GslMatrix.h
src/core/src/GslMatrix.C

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation