MatrixMarket_CoordDataReader.hpp

// @HEADER
// ***********************************************************************
// 
//          Tpetra: Templated Linear Algebra Services Package
//                 Copyright (2008) Sandia Corporation
// 
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
// 
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the Corporation nor the names of the
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Questions? Contact Michael A. Heroux (maherou@sandia.gov) 
// 
// ************************************************************************
// @HEADER

#ifndef __MatrixMarket_CoordDataReader_hpp
#define __MatrixMarket_CoordDataReader_hpp

#include "MatrixMarket_generic.hpp"

namespace Tpetra {
  namespace MatrixMarket {

    template<class Callback, class Ordinal> 
    class CoordDataReaderBase {
    protected:
      RCP<Callback> adder_;

    public:
      CoordDataReaderBase (const RCP<Callback>& adder) : 
  adder_ (adder) {}

      CoordDataReaderBase () : adder_ (null) {}

      virtual ~CoordDataReaderBase () {}

      void setAdder (const 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; 
  size_t validDataLines = 0;
  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);
    }
    else {
      ++validDataLines;
    }
  }
  return std::make_pair (allSucceeded, badLineNumbers);
      }

      std::pair<Tuple<Ordinal, 3>, bool>
      readDimensions (std::istream& in, 
          size_t& lineNumber,
          const bool tolerant = false)
      {
  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 = ScalarTraits<Scalar>::isComplex>
    class CoordDataReader : public CoordDataReaderBase<Callback, Ordinal> {
    public:
      CoordDataReader (const RCP<Callback>& adder);
      CoordDataReader ();

      virtual ~CoordDataReader();

    protected:
      bool
      readLine (const std::string& theLine, 
    const size_t lineNumber,
    const bool tolerant);
    };

#ifdef HAVE_TEUCHOS_COMPLEX
    // 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 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 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

    // 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 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 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 Tpetra

#endif // __MatrixMarket_CoordDataReader_hpp