Teuchos_MatrixMarket_CoordDataReader.hpp

// @HEADER
// *****************************************************************************
//          Tpetra: Templated Linear Algebra Services Package
//
// Copyright 2008 NTESS and the Tpetra contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
#ifndef __Teuchos_MatrixMarket_CoordDataReader_hpp
#define __Teuchos_MatrixMarket_CoordDataReader_hpp
 
#include "Teuchos_MatrixMarket_generic.hpp"
#include "Teuchos_RCP.hpp"
#include "Teuchos_ScalarTraits.hpp"
#include "Teuchos_Tuple.hpp"
 
 
namespace Teuchos {
  namespace MatrixMarket {
    template<class Callback, class Ordinal>
    class CoordDataReaderBase {
    protected:
      Teuchos::RCP<Callback> adder_;
 
    public:
      CoordDataReaderBase (const Teuchos::RCP<Callback>& adder) :
        adder_ (adder) {}

      CoordDataReaderBase () : adder_ (null) {}

      virtual ~CoordDataReaderBase () {}

      void setAdder (const Teuchos::RCP<Callback>& adder) {
        adder_ = adder;
      }
 
    protected:
      virtual bool
      readLine (const std::string& theLine,
                const size_t lineNumber,
                const bool tolerant) = 0;
 
    public:

      virtual std::pair<bool, std::vector<size_t> >
      read (std::istream& in,
            const size_t startingLineNumber,
            const bool tolerant,
            const bool debug = false)
      {
        (void) debug; // silence unused input argument warning
        TEUCHOS_TEST_FOR_EXCEPTION(! in, std::invalid_argument,
          "Input stream is invalid.");
 
        std::string line;
        size_t lineNumber = startingLineNumber;
        bool allSucceeded = true;
        std::vector<size_t> badLineNumbers;
        while (getline (in, line)) {
          size_t start, size;
          if (checkCommentLine (line, start, size, lineNumber, tolerant)) {
            ++lineNumber;
            continue; // it's a comment line
          }
          const std::string theLine = line.substr (start, size);
 
          const bool localSuccess = readLine (theLine, lineNumber, tolerant);
          ++lineNumber;
          allSucceeded = allSucceeded && localSuccess;
          if (! localSuccess) {
            badLineNumbers.push_back (lineNumber);
          }
        }
        return std::make_pair (allSucceeded, badLineNumbers);
      }

      std::pair<Teuchos::Tuple<Ordinal, 3>, bool>
      readDimensions (std::istream& in,
                      size_t& lineNumber,
                      const bool tolerant = false)
      {
        Teuchos::Tuple<Ordinal, 3> dims;
        // Fill in (numRows, numCols, numNonzeros) with reasonable
        // defaults.  If we don't succeed in reading all the data
        // from the current line of the input stream, the remaining
        // values not read will be these default values.
        dims[0] = 0;
        dims[1] = 0;
        dims[2] = 0;
 
        // Keep reading lines from the input stream until we find a
        // non-comment line, or until we run out of lines.  The latter
        // is an error, since every "coordinate" format Matrix Market
        // file must have a dimensions line after the banner (even if
        // the matrix has zero rows or columns, or zero entries).
        std::string line;
        bool commentLine = true;
        while (commentLine) {
          // Is it even valid to read from the input stream?
          if (in.eof() || in.fail()) {
            if (tolerant) {
              return std::make_pair (dims, false);
            }
            else {
              std::ostringstream os;
              os << "Unable to get coordinate dimensions line (at all) "
                "from (line " << lineNumber << ") of input stream; the "
                "input stream claims that it is at \"end-of-file\" or has "
                "an otherwise \"fail\"ed state.";
              throw std::invalid_argument(os.str());
            }
          }
          // Try to get the next line from the input stream.
          if (getline(in, line)) {
            lineNumber++; // We did actually read a line
          }
          else {
            if (tolerant) {
              return std::make_pair (dims, false);
            }
            else {
              std::ostringstream os;
              os << "Failed to read coordinate dimensions line (at all) "
                "from (line " << lineNumber << " from input stream.  The "
                "line should contain the coordinate matrix dimensions in "
                 << " the form \"<numRows> <numCols> <numNonzeros>\".";
              throw std::invalid_argument (os.str());
            }
          }
          // Is the current line a comment line?  Ignore start and
          // size; they are only useful for reading the actual matrix
          // entries.  (We could use them here as an optimization, but
          // we've chosen not to.)
          size_t start = 0, size = 0;
          commentLine = checkCommentLine (line, start, size,
                                          lineNumber, tolerant);
        }
        //
        // Read in <numRows> <numCols> <numNonzeros> from input line
        //
        std::istringstream istr (line);
        // Does line contain anything at all?  Can we safely read from
        // the input stream wrapping the line?
        if (istr.eof() || istr.fail()) {
          if (tolerant) {
            return std::make_pair (dims, false);
          }
          std::ostringstream os;
          os << "Unable to read any data from line " << lineNumber
             << " of input; the line should contain the coordinate matrix "
             << "dimensions \"<numRows> <numCols> <numNonzeros>\".";
          throw std::invalid_argument(os.str());
        }
        // Read in <numRows>
        {
          Ordinal theNumRows = 0;
          istr >> theNumRows;
          if (istr.fail()) {
            if (tolerant) {
              return std::make_pair (dims, false);
            }
            std::ostringstream os;
            os << "Failed to get number of rows from line " << lineNumber
               << " of input; the line should contain the coordinate matrix "
               << " dimensions \"<numRows> <numCols> <numNonzeros>\".";
            throw std::invalid_argument(os.str());
          }
          else { // Capture the validly read result before checking for eof.
            dims[0] = theNumRows;
          }
        }
        // There should be two more things to read.
        if (istr.eof()) {
          if (tolerant) {
            return std::make_pair (dims, false);
          }
          std::ostringstream os;
          os << "No more data after number of rows on line " << lineNumber
             << " of input; the line should contain the coordinate matrix "
             << " dimensions \"<numRows> <numCols> <numNonzeros>\".";
          throw std::invalid_argument(os.str());
        }
        // Read in <numCols>
        {
          Ordinal theNumCols = 0;
          istr >> theNumCols;
          if (istr.fail()) {
            if (tolerant) {
              return std::make_pair (dims, false);
            }
            std::ostringstream os;
            os << "Failed to get number of columns from line " << lineNumber
               << " of input; the line should contain the coordinate matrix "
               << " dimensions \"<numRows> <numCols> <numNonzeros>\".";
            throw std::invalid_argument(os.str());
          }
          else { // Capture the validly read result before checking for eof.
            dims[1] = theNumCols;
          }
        }
        // There should be one more thing to read.
        if (istr.eof()) {
          if (tolerant) {
            return std::make_pair (dims, false);
          }
          std::ostringstream os;
          os << "No more data after number of columns on line " << lineNumber
             << " of input; the line should contain the coordinate matrix "
             << " dimensions \"<numRows> <numCols> <numNonzeros>\".";
          throw std::invalid_argument(os.str());
        }
        // Read in <numNonzeros>
        {
          Ordinal theNumNonzeros = 0;
          istr >> theNumNonzeros;
          if (istr.fail()) {
            if (tolerant) {
              return std::make_pair (dims, false);
            }
            std::ostringstream os;
            os << "Failed to get number of (structural) nonzeros from line "
               << lineNumber
               << " of input; the line should contain the coordinate matrix "
               << " dimensions \"<numRows> <numCols> <numNonzeros>\".";
            throw std::invalid_argument(os.str());
          }
          else { // Capture the validly read result
            dims[2] = theNumNonzeros;
          }
        }
        // It would be nice to validate the read-in data further.  The
        // only thing we can do now is test if it's negative.  However,
        // we don't know syntactically whether Ordinal is a signed or
        // unsigned type, so we shouldn't even test for negativity.
        return std::make_pair (dims, true);
      }
    };

    template<class Callback,
             class Ordinal,
             class Scalar,
             bool isComplex = Teuchos::ScalarTraits<Scalar>::isComplex>
    class CoordDataReader : public CoordDataReaderBase<Callback, Ordinal> {
    public:
      CoordDataReader (const Teuchos::RCP<Callback>& adder);

      CoordDataReader ();

      virtual ~CoordDataReader();
 
    protected:
      bool
      readLine (const std::string& theLine,
                const size_t lineNumber,
                const bool tolerant);
    };
 
#ifdef HAVE_TEUCHOS_COMPLEX
    // Partial specialization for complex Scalar types.
    template<class Callback, class Ordinal, class Scalar>
    class CoordDataReader<Callback, Ordinal, Scalar, true> :
      public CoordDataReaderBase<Callback, Ordinal> {
    public:
      CoordDataReader (const Teuchos::RCP<Callback>& adder) :
        CoordDataReaderBase<Callback, Ordinal> (adder)
      {}
 
      CoordDataReader() :
        CoordDataReaderBase<Callback, Ordinal> (null)
      {}
 
      virtual ~CoordDataReader() {};
 
    protected:
      bool
      readLine (const std::string& theLine,
                const size_t lineNumber,
                const bool tolerant)
      {
        typedef Teuchos::ScalarTraits<Scalar> STS;
        typedef typename STS::magnitudeType Real;
 
        Ordinal rowIndex;
        Ordinal colIndex;
        Scalar value;
 
        Real realPart, imagPart;
        const bool localSuccess =
          readComplexLine (theLine, rowIndex, colIndex, realPart, imagPart,
                           lineNumber, tolerant);
        if (localSuccess) {
          // Assume that assignment from std::complex<Real> to Scalar
          // (which itself is complex-valued) is valid.  We have to do
          // this, since the C++ compiler may not be smart enough to
          // assume here (when it instantiates the templates) that
          // Scalar is an std::complex<Real> -- even though it has to
          // be, if STS::isComplex is true (which as of 31 Jan 2011,
          // only holds for std::complex<T>).
          value = std::complex<Real> (realPart, imagPart);
 
          // Now that we've read in the (i, j, A_ij) triple
          // successfully, we can add the entry to the sparse matrix.
          (*(this->adder_)) (rowIndex, colIndex, value);
        }
        return localSuccess;
      }
    };
#endif // HAVE_TEUCHOS_COMPLEX
 
    // Partial specialization for real Scalar types.
    template<class Callback, class Ordinal, class Scalar>
    class CoordDataReader<Callback, Ordinal, Scalar, false> :
      public CoordDataReaderBase<Callback, Ordinal> {
    public:
      CoordDataReader (const Teuchos::RCP<Callback>& adder) :
        CoordDataReaderBase<Callback, Ordinal> (adder)
      {}
 
      CoordDataReader() :
        CoordDataReaderBase<Callback, Ordinal> (null)
      {}
 
      virtual ~CoordDataReader() {};
 
    protected:
      bool
      readLine (const std::string& theLine,
                const size_t lineNumber,
                const bool tolerant)
      {
        Ordinal rowIndex;
        Ordinal colIndex;
        Scalar value;
        const bool localSuccess = readRealLine (theLine, rowIndex, colIndex,
                                                value, lineNumber, tolerant);
        if (localSuccess) {
          // Now that we've read in the (i, j, A_ij) triple
          // successfully, we can add the entry to the sparse matrix.
          (*(this->adder_)) (rowIndex, colIndex, value);
        }
        return localSuccess;
      }
    };
 

    template<class Callback, class Ordinal>
    class CoordPatternReader : public CoordDataReaderBase<Callback, Ordinal> {
    public:
      CoordPatternReader (const Teuchos::RCP<Callback>& adder) :
        CoordDataReaderBase<Callback, Ordinal> (adder)
      {}

      CoordPatternReader() :
        CoordDataReaderBase<Callback, Ordinal> (null)
      {}

      virtual ~CoordPatternReader() {};
 
    protected:
      bool
      readLine (const std::string& theLine,
                const size_t lineNumber,
                const bool tolerant)
      {
        Ordinal rowIndex;
        Ordinal colIndex;
        const bool localSuccess =
          readPatternLine (theLine, rowIndex, colIndex, lineNumber, tolerant);
        if (localSuccess) {
          // Now that we've read in the (i, j) pair successfully, we
          // can add the entry to the sparse graph.
          (*(this->adder_)) (rowIndex, colIndex);
        }
        return localSuccess;
      }
    };
 
  } // namespace MatrixMarket
} // namespace Teuchos
 
#endif // __Teuchos_MatrixMarket_CoordDataReader_hpp