Iterator to browse matrices from a specified folder. More...

#include <MatrixMarketIterator.h>

Public Types
typedef Matrix< Scalar, Dynamic, 1 >	VectorType

typedef SparseMatrix< Scalar, ColMajor >	MatrixType

Public Member Functions
	MatrixMarketIterator (const std::string &folder)

	~MatrixMarketIterator ()

MatrixMarketIterator &	operator++ ()

	operator bool () const

MatrixType &	matrix ()

VectorType &	rhs ()

VectorType &	refX ()

std::string &	matname ()

int	sym ()

bool	hasRhs ()

bool	hasrefX ()

bool	isFolderValid ()

Protected Member Functions
bool	Fileexists (std::string file)

void	Getnextvalidmatrix ()

Protected Attributes
int	m_sym

MatrixType	m_mat

VectorType	m_rhs

VectorType	m_refX

std::string	m_matname

bool	m_isvalid

bool	m_matIsLoaded

bool	m_hasRhs

bool	m_hasrefX

std::string	m_folder

DIR *	m_folder_id

struct dirent *	m_curs_id

Private Types
typedef NumTraits< Scalar >::Real	RealScalar

Detailed Description

template<typename Scalar>
class Eigen::MatrixMarketIterator< Scalar >

Iterator to browse matrices from a specified folder.

This is used to load all the matrices from a folder. The matrices should be in Matrix Market format It is assumed that the matrices are named as matname.mtx and matname_SPD.mtx if the matrix is Symmetric and positive definite (or Hermitian) The right hand side vectors are loaded as well, if they exist. They should be named as matname_b.mtx. Note that the right hand side for a SPD matrix is named as matname_SPD_b.mtx

Sometimes a reference solution is available. In this case, it should be named as matname_x.mtx

Sample code

Template Parameters

Scalar The scalar type

Member Typedef Documentation

◆ MatrixType

template<typename Scalar >

typedef SparseMatrix<Scalar, ColMajor> Eigen::MatrixMarketIterator< Scalar >::MatrixType

◆ RealScalar

template<typename Scalar >

typedef NumTraits<Scalar>::Real Eigen::MatrixMarketIterator< Scalar >::RealScalar

private

◆ VectorType

template<typename Scalar >

typedef Matrix<Scalar, Dynamic, 1> Eigen::MatrixMarketIterator< Scalar >::VectorType

Constructor & Destructor Documentation

◆ MatrixMarketIterator()

template<typename Scalar >

Eigen::MatrixMarketIterator< Scalar >::MatrixMarketIterator ( const std::string & folder )

inline

       : m_sym(0), m_isvalid(false), m_matIsLoaded(false), m_hasRhs(false), m_hasrefX(false), m_folder(folder) {
     m_folder_id = opendir(folder.c_str());
     if (m_folder_id) Getnextvalidmatrix();
   }

References Eigen::MatrixMarketIterator< Scalar >::Getnextvalidmatrix(), and Eigen::MatrixMarketIterator< Scalar >::m_folder_id.

◆ ~MatrixMarketIterator()

template<typename Scalar >

Eigen::MatrixMarketIterator< Scalar >::~MatrixMarketIterator ( )

inline

                           {
     if (m_folder_id) closedir(m_folder_id);
   }

References Eigen::MatrixMarketIterator< Scalar >::m_folder_id.

Member Function Documentation

◆ Fileexists()

template<typename Scalar >

bool Eigen::MatrixMarketIterator< Scalar >::Fileexists ( std::string file )

inlineprotected

                                          {
     std::ifstream file_id(file.c_str());
     if (!file_id.good()) {
       return false;
     } else {
       file_id.close();
       return true;
     }
   }

Referenced by Eigen::MatrixMarketIterator< Scalar >::refX(), and Eigen::MatrixMarketIterator< Scalar >::rhs().

◆ Getnextvalidmatrix()

template<typename Scalar >

void Eigen::MatrixMarketIterator< Scalar >::Getnextvalidmatrix ( )

inlineprotected

                             {
     m_isvalid = false;
     // Here, we return with the next valid matrix in the folder
     while ((m_curs_id = readdir(m_folder_id)) != NULL) {
       m_isvalid = false;
       std::string curfile;
       curfile = m_folder + "/" + m_curs_id->d_name;
       // Discard if it is a folder
       if (m_curs_id->d_type == DT_DIR) continue;  // FIXME This may not be available on non BSD systems
       //         struct stat st_buf;
       //         stat (curfile.c_str(), &st_buf);
       //         if (S_ISDIR(st_buf.st_mode)) continue;
  
       // Determine from the header if it is a matrix or a right hand side
       bool isvector, iscomplex = false;
       if (!getMarketHeader(curfile, m_sym, iscomplex, isvector)) continue;
       if (isvector) continue;
       if (!iscomplex) {
         if (internal::is_same<Scalar, std::complex<float> >::value ||
             internal::is_same<Scalar, std::complex<double> >::value)
           continue;
       }
       if (iscomplex) {
         if (internal::is_same<Scalar, float>::value || internal::is_same<Scalar, double>::value) continue;
       }
  
       // Get the matrix name
       std::string filename = m_curs_id->d_name;
       m_matname = filename.substr(0, filename.length() - 4);
  
       // Find if the matrix is SPD
       size_t found = m_matname.find("SPD");
       if ((found != std::string::npos) && (m_sym != NonSymmetric)) m_sym = SPD;
  
       m_isvalid = true;
       break;
     }
   }

References MergeRestartFiles::filename, MergeRestartFiles::found, Eigen::getMarketHeader(), Eigen::MatrixMarketIterator< Scalar >::m_curs_id, Eigen::MatrixMarketIterator< Scalar >::m_folder, Eigen::MatrixMarketIterator< Scalar >::m_folder_id, Eigen::MatrixMarketIterator< Scalar >::m_isvalid, Eigen::MatrixMarketIterator< Scalar >::m_matname, Eigen::MatrixMarketIterator< Scalar >::m_sym, Eigen::NonSymmetric, Eigen::SPD, oomph::Global_string_for_annotation::string(), and Eigen::value.

Referenced by Eigen::MatrixMarketIterator< Scalar >::MatrixMarketIterator(), and Eigen::MatrixMarketIterator< Scalar >::operator++().

◆ hasrefX()

template<typename Scalar >

bool Eigen::MatrixMarketIterator< Scalar >::hasrefX ( )

inline

152 { return m_hasrefX; }

References Eigen::MatrixMarketIterator< Scalar >::m_hasrefX.

Referenced by Browse_Matrices().

◆ hasRhs()

template<typename Scalar >

bool Eigen::MatrixMarketIterator< Scalar >::hasRhs ( )

inline

151 { return m_hasRhs; }

References Eigen::MatrixMarketIterator< Scalar >::m_hasRhs.

◆ isFolderValid()

template<typename Scalar >

bool Eigen::MatrixMarketIterator< Scalar >::isFolderValid ( )

inline

153 { return bool(m_folder_id); }

bool

References Eigen::MatrixMarketIterator< Scalar >::m_folder_id.

◆ matname()

template<typename Scalar >

std::string& Eigen::MatrixMarketIterator< Scalar >::matname ( )

inline

147 { return m_matname; }

References Eigen::MatrixMarketIterator< Scalar >::m_matname.

Referenced by Browse_Matrices(), check_sparse_spd_solving(), and check_sparse_square_solving().

◆ matrix()

template<typename Scalar >

MatrixType& Eigen::MatrixMarketIterator< Scalar >::matrix ( )

inline

Return the sparse matrix corresponding to the current file

                               {
     // Read the matrix
     if (m_matIsLoaded) return m_mat;
  
     std::string matrix_file = m_folder + "/" + m_matname + ".mtx";
     if (!loadMarket(m_mat, matrix_file)) {
       std::cerr << "Warning loadMarket failed when loading \"" << matrix_file << "\"" << std::endl;
       m_matIsLoaded = false;
       return m_mat;
     }
     m_matIsLoaded = true;
  
     if (m_sym != NonSymmetric) {
       // Check whether we need to restore a full matrix:
       RealScalar diag_norm = m_mat.diagonal().norm();
       RealScalar lower_norm = m_mat.template triangularView<Lower>().norm();
       RealScalar upper_norm = m_mat.template triangularView<Upper>().norm();
       if (lower_norm > diag_norm && upper_norm == diag_norm) {
         // only the lower part is stored
         MatrixType tmp(m_mat);
         m_mat = tmp.template selfadjointView<Lower>();
       } else if (upper_norm > diag_norm && lower_norm == diag_norm) {
         // only the upper part is stored
         MatrixType tmp(m_mat);
         m_mat = tmp.template selfadjointView<Upper>();
       }
     }
     return m_mat;
   }

References Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::diagonal(), Eigen::loadMarket(), Eigen::MatrixMarketIterator< Scalar >::m_folder, Eigen::MatrixMarketIterator< Scalar >::m_mat, Eigen::MatrixMarketIterator< Scalar >::m_matIsLoaded, Eigen::MatrixMarketIterator< Scalar >::m_matname, Eigen::MatrixMarketIterator< Scalar >::m_sym, Eigen::NonSymmetric, Eigen::SparseMatrixBase< Derived >::norm(), oomph::Global_string_for_annotation::string(), and tmp.

Referenced by Browse_Matrices(), check_sparse_spd_solving(), check_sparse_square_solving(), and Eigen::MatrixMarketIterator< Scalar >::rhs().

◆ operator bool()

template<typename Scalar >

Eigen::MatrixMarketIterator< Scalar >::operator bool ( ) const

inline

67 { return m_isvalid; }

References Eigen::MatrixMarketIterator< Scalar >::m_isvalid.

◆ operator++()

template<typename Scalar >

MatrixMarketIterator& Eigen::MatrixMarketIterator< Scalar >::operator++ ( )

inline

                                             {
     m_matIsLoaded = false;
     m_hasrefX = false;
     m_hasRhs = false;
     Getnextvalidmatrix();
     return *this;
   }

References Eigen::MatrixMarketIterator< Scalar >::Getnextvalidmatrix(), Eigen::MatrixMarketIterator< Scalar >::m_hasrefX, Eigen::MatrixMarketIterator< Scalar >::m_hasRhs, and Eigen::MatrixMarketIterator< Scalar >::m_matIsLoaded.

◆ refX()

template<typename Scalar >

VectorType& Eigen::MatrixMarketIterator< Scalar >::refX ( )

inline

Return a reference solution If it is not provided and if the right hand side is not available then refX is randomly generated such that A*refX = b where A and b are the matrix and the rhs. Note that when a rhs is provided, refX is not available

                             {
     // Check if a reference solution is provided
     if (m_hasrefX) return m_refX;
  
     std::string lhs_file;
     lhs_file = m_folder + "/" + m_matname + "_x.mtx";
     m_hasrefX = Fileexists(lhs_file);
     if (m_hasrefX) {
       m_refX.resize(m_mat.cols());
       m_hasrefX = loadMarketVector(m_refX, lhs_file);
     } else
       m_refX.resize(0);
     return m_refX;
   }

References Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::cols(), Eigen::MatrixMarketIterator< Scalar >::Fileexists(), Eigen::loadMarketVector(), Eigen::MatrixMarketIterator< Scalar >::m_folder, Eigen::MatrixMarketIterator< Scalar >::m_hasrefX, Eigen::MatrixMarketIterator< Scalar >::m_mat, Eigen::MatrixMarketIterator< Scalar >::m_matname, Eigen::MatrixMarketIterator< Scalar >::m_refX, Eigen::PlainObjectBase< Derived >::resize(), and oomph::Global_string_for_annotation::string().

Referenced by Browse_Matrices(), check_sparse_spd_solving(), and check_sparse_square_solving().

◆ rhs()

template<typename Scalar >

VectorType& Eigen::MatrixMarketIterator< Scalar >::rhs ( )

inline

Return the right hand side corresponding to the current matrix. If the rhs file is not provided, a random rhs is generated

                            {
     // Get the right hand side
     if (m_hasRhs) return m_rhs;
  
     std::string rhs_file;
     rhs_file = m_folder + "/" + m_matname + "_b.mtx";  // The pattern is matname_b.mtx
     m_hasRhs = Fileexists(rhs_file);
     if (m_hasRhs) {
       m_rhs.resize(m_mat.cols());
       m_hasRhs = loadMarketVector(m_rhs, rhs_file);
     }
     if (!m_hasRhs) {
       // Generate a random right hand side
       if (!m_matIsLoaded) this->matrix();
       m_refX.resize(m_mat.cols());
       m_refX.setRandom();
       m_rhs = m_mat * m_refX;
       m_hasrefX = true;
       m_hasRhs = true;
     }
     return m_rhs;
   }