SparseExtra module

Classes
class	Eigen::RandomSetter< SparseMatrixType, MapTraits, OuterPacketBits >
	The RandomSetter is a wrapper object allowing to set/update a sparse matrix with random access. More...

Functions
bool	Eigen::getMarketHeader (const std::string &filename, int &sym, bool &iscomplex, bool &isdense)
	Reads the header of a matrixmarket file and determines the properties of a matrix. More...
template<typename SparseMatrixType >
bool	Eigen::loadMarket (SparseMatrixType &mat, const std::string &filename)
	Loads a sparse matrix from a matrixmarket format file. More...
template<typename DenseType >
bool	Eigen::loadMarketDense (DenseType &mat, const std::string &filename)
	Loads a dense Matrix or Vector from a matrixmarket file. If a statically sized matrix has to be parsed and the file contains the wrong dimensions it is undefined behaviour. More...
template<typename VectorType >
bool	Eigen::loadMarketVector (VectorType &vec, const std::string &filename)
	Same functionality as loadMarketDense, deprecated. More...
template<typename SparseMatrixType >
bool	Eigen::saveMarket (const SparseMatrixType &mat, const std::string &filename, int sym=0)
	writes a sparse Matrix to a marketmarket format file More...
template<typename DenseType >
bool	Eigen::saveMarketDense (const DenseType &mat, const std::string &filename)
	writes a dense Matrix or vector to a marketmarket format file More...
template<typename VectorType >
bool	Eigen::saveMarketVector (const VectorType &vec, const std::string &filename)
	Same functionality as saveMarketDense, deprecated. More...

Detailed Description

This module contains some experimental features extending the sparse module:

• A RandomSetter which is a wrapper object allowing to set/update a sparse matrix with random access.
• A SparseInverse which calculates a sparse subset of the inverse of a sparse matrix corresponding to nonzeros of the input
• MatrixMarket format(https://math.nist.gov/MatrixMarket/formats.html) readers and writers for sparse and dense matrices.

#include <unsupported/Eigen/SparseExtra>

Function Documentation

getMarketHeader()

bool Eigen::getMarketHeader ( const std::string &  filename, int &  sym, bool &  iscomplex, bool &  isdense  )

inline

Reads the header of a matrixmarket file and determines the properties of a matrix.

Parameters

filename	of the file
sym	if the matrix is hermitian,symmetric or none of the latter (sym=0)
iscomplex	if the matrix has complex or real coefficients
isdense	if the matrix is dense or sparse

Returns

true if the file was found

Definition at line 122 of file MarketIO.h.

{
  sym = 0; 
  iscomplex = false;
  isdense = false;
  std::ifstream in(filename.c_str(),std::ios::in);
  if(!in)
    return false;
  
  std::string line; 
  // The matrix header is always the first line in the file 
  std::getline(in, line); eigen_assert(in.good());
  
  std::stringstream fmtline(line); 
  std::string substr[5];
  fmtline>> substr[0] >> substr[1] >> substr[2] >> substr[3] >> substr[4];
  if(substr[2].compare("array") == 0) isdense = true;
  if(substr[3].compare("complex") == 0) iscomplex = true;
  if(substr[4].compare("symmetric") == 0) sym = Symmetric;
  else if (substr[4].compare("Hermitian") == 0) sym = SelfAdjoint;
  
  return true;
}

loadMarket()

template<typename SparseMatrixType >

bool Eigen::loadMarket	(	SparseMatrixType &	mat,
		const std::string &	filename
	)

Loads a sparse matrix from a matrixmarket format file.

Template Parameters

SparseMatrixType

to read into, symmetries are not supported

Parameters

mat	SparseMatrix to read into, current values are overwritten
filename	to parse matrix from

Returns

returns true if file exists. Returns false if the parsing did not succeed.

Definition at line 155 of file MarketIO.h.

{
  typedef typename SparseMatrixType::Scalar Scalar;
  typedef typename SparseMatrixType::StorageIndex StorageIndex;
  std::ifstream input(filename.c_str(),std::ios::in);
  if(!input)
    return false;
 
  char rdbuffer[4096];
  input.rdbuf()->pubsetbuf(rdbuffer, 4096);
  
  const int maxBuffersize = 2048;
  char buffer[maxBuffersize];
  
  bool readsizes = false;
 
  typedef Triplet<Scalar,StorageIndex> T;
  std::vector<T> elements;
  
  Index M(-1), N(-1), NNZ(-1);
  Index count = 0;
  while(input.getline(buffer, maxBuffersize))
  {
    // skip comments   
    //NOTE An appropriate test should be done on the header to get the  symmetry
    if(buffer[0]=='%')
      continue;
 
    if(!readsizes)
    {
      std::stringstream line(buffer);
      line >> M >> N >> NNZ;
      if(M > 0 && N > 0)
      {
        readsizes = true;
        mat.resize(M,N);
        mat.reserve(NNZ);
        elements.reserve(NNZ);
      }
    }
    else
    { 
      StorageIndex i(-1), j(-1);
      Scalar value; 
      internal::GetMarketLine(buffer, i, j, value);
 
      i--;
      j--;
      if(i>=0 && j>=0 && i<M && j<N)
      {
        ++count;
        elements.push_back(T(i,j,value));
      }
      else
      {
        std::cerr << "Invalid read: " << i << "," << j << "\n";   
        return false;
      }     
    }
  }
 
  mat.setFromTriplets(elements.begin(), elements.end());
  if(count!=NNZ){
    std::cerr << count << "!=" << NNZ << "\n";
    return false;
  }
  input.close();
  return true;
}

loadMarketDense()

template<typename DenseType >

bool Eigen::loadMarketDense	(	DenseType &	mat,
		const std::string &	filename
	)

Loads a dense Matrix or Vector from a matrixmarket file. If a statically sized matrix has to be parsed and the file contains the wrong dimensions it is undefined behaviour.

Template Parameters

DenseMatrixType

to read into

Parameters

mat	DenseMatrix to read into, current values are overwritten, symmetries are not supported
filename	to parse matrix from

Returns

true if parsing was successful. Returns false if the parsing did not succeed.

Definition at line 236 of file MarketIO.h.

{
   typedef typename DenseType::Scalar Scalar;
  std::ifstream in(filename.c_str(), std::ios::in);
  if(!in)
    return false;
  
  std::string line; 
  Index rows(0), cols(0); 
  do 
  { // Skip comments
    std::getline(in, line); eigen_assert(in.good());
  } while (line[0] == '%');
  std::istringstream newline(line);
  newline  >> rows >> cols; 
 
  bool sizes_not_positive=(rows<1 || cols<1);
  bool wrong_input_rows = (DenseType::MaxRowsAtCompileTime != Dynamic && rows > DenseType::MaxRowsAtCompileTime) ||
                          (DenseType::RowsAtCompileTime!=Dynamic && rows!=DenseType::RowsAtCompileTime);
  bool wrong_input_cols = (DenseType::MaxColsAtCompileTime != Dynamic && cols > DenseType::MaxColsAtCompileTime) ||
                          (DenseType::ColsAtCompileTime!=Dynamic && cols!=DenseType::ColsAtCompileTime);
 
  if(sizes_not_positive || wrong_input_rows || wrong_input_cols){
    if(sizes_not_positive){
      std::cerr<< "non-positive row or column size in file" << filename << "\n";
    }else{
      std::cerr<< "Input matrix can not be resized to"<<rows<<" x "<<cols<< "as given in " << filename << "\n";
    }
    in.close();
    return false;
  }
 
  mat.resize(rows,cols);
  Index row = 0;
  Index col = 0; 
  Index n=0;
  Scalar value; 
  while ( std::getline(in, line) && (row < rows) && (col < cols)){
    internal::GetDenseElt(line, value); 
    //matrixmarket format is column major
    mat(row,col) = value; 
    row++;
    if(row==rows){
      row=0;
      col++;
    }
    n++;
  }
  in.close();
  if (n!=mat.size()){
    std::cerr<< "Unable to read all elements from file " << filename << "\n";
    return false;
  }
  return true;
}

loadMarketVector()

template<typename VectorType >

bool Eigen::loadMarketVector	(	VectorType &	vec,
		const std::string &	filename
	)

Same functionality as loadMarketDense, deprecated.

Definition at line 296 of file MarketIO.h.

{
 return loadMarketDense(vec, filename);
}

saveMarket()

template<typename SparseMatrixType >

bool Eigen::saveMarket	(	const SparseMatrixType &	mat,
		const std::string &	filename,
		int	sym = 0
	)

writes a sparse Matrix to a marketmarket format file

Template Parameters

SparseMatrixType

to write to file

Parameters

mat	matrix to write to file
filename	filename to write to
sym	at the moment no symmetry operations are supported

Returns

true if writing succeeded

Definition at line 312 of file MarketIO.h.

{
  typedef typename SparseMatrixType::Scalar Scalar;
  typedef typename SparseMatrixType::RealScalar RealScalar;
  std::ofstream out(filename.c_str(),std::ios::out);
  if(!out)
    return false;
  
  out.flags(std::ios_base::scientific);
  out.precision(std::numeric_limits<RealScalar>::digits10 + 2);
  std::string header; 
  internal::putMarketHeader<Scalar>(header, sym); 
  out << header << std::endl; 
  out << mat.rows() << " " << mat.cols() << " " << mat.nonZeros() << "\n";
  int count = 0;
  for(int j=0; j<mat.outerSize(); ++j)
    for(typename SparseMatrixType::InnerIterator it(mat,j); it; ++it)
    {
      ++ count;
      internal::PutMatrixElt(it.value(), it.row()+1, it.col()+1, out);
    }
  out.close();
  return true;
}

saveMarketDense()

template<typename DenseType >

bool Eigen::saveMarketDense	(	const DenseType &	mat,
		const std::string &	filename
	)

writes a dense Matrix or vector to a marketmarket format file

Template Parameters

DenseMatrixType

to write to file

Parameters

mat	matrix to write to file
filename	filename to write to

Returns

true if writing succeeded

Definition at line 349 of file MarketIO.h.

{
 typedef typename DenseType::Scalar Scalar;
 typedef typename DenseType::RealScalar RealScalar;
 std::ofstream out(filename.c_str(),std::ios::out);
  if(!out)
    return false;
  
  out.flags(std::ios_base::scientific);
  out.precision(std::numeric_limits<RealScalar>::digits10 + 2);
  if(internal::is_same<Scalar, std::complex<float> >::value || internal::is_same<Scalar, std::complex<double> >::value)
      out << "%%MatrixMarket matrix array complex general\n"; 
  else
    out << "%%MatrixMarket matrix array real general\n"; 
  out << mat.rows() << " "<< mat.cols() << "\n";
  for (Index i=0; i < mat.cols(); i++){
    for (Index j=0; j < mat.rows(); j++){
      internal::putDenseElt(mat(j,i), out); 
    }
  }
  out.close();
  return true; 
}

saveMarketVector()

template<typename VectorType >

bool Eigen::saveMarketVector	(	const VectorType &	vec,
		const std::string &	filename
	)

Same functionality as saveMarketDense, deprecated.

Definition at line 378 of file MarketIO.h.

{
  return saveMarketDense(vec, filename);
}