src/matrixmarket/mtxdataiterator.cpp

Go to the documentation of this file.

/***************************************************************************
                          mtxdataiterator.cpp  -  description
                             -------------------
    begin                : Thu Dec 4 2003
    copyright            : (C) 2003 by Roman Geus
    email                : roman.geus@psi.ch
***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#include <algorithm>
#include <stdexcept>
#include <iostream>
#include <iomanip>
#include <string>
#include "mtxdataiterator.h"

MtxDataIterator::MtxDataIterator(istream& istr, bool iterate_mirror)
    : _istr(&istr), _nnz_read(0)
{
    read_header();
    if (get_storage_scheme() == general)
        _iterate_mirror = false;
    else
        _iterate_mirror = iterate_mirror;
    _last_mirrored = false;
    read_next_triplet();
}

MtxDataIterator::~MtxDataIterator()
{}

void MtxDataIterator::read_header()
{
    std::string banner, mtx, crd, dataType, storageScheme;
    std::istream& istr = *_istr;

    //
    // Read banner
    //
    if (!(istr >> banner >> mtx >> crd >> dataType >> storageScheme))
        throw std::runtime_error("Error reading header line");

    // convert to lower case
    int (*pf)(int)=tolower;
    std::transform(banner.begin(), banner.end(), banner.begin(), pf);
    std::transform(mtx.begin(), mtx.end(), mtx.begin(), pf);
    std::transform(crd.begin(), crd.end(), crd.begin(), pf);
    std::transform(dataType.begin(), dataType.end(), dataType.begin(), pf);
    std::transform(storageScheme.begin(), storageScheme.end(), storageScheme.begin(), pf);

    if (banner != "%%matrixmarket")
        throw std::runtime_error("Invalid header");

    if (mtx != "matrix")
        throw std::runtime_error("Unsupported matrix type");

    if (crd != "coordinate")
        throw std::runtime_error("Unsupported matrix storage format");
    _matrix_type = sparse;

    if (dataType == "real")
        _element_type = real;
    else if (dataType == "complex")
        _element_type = complex;
    else if (dataType == "integer")
        _element_type = integer;
    else if (dataType == "pattern")
        _element_type = pattern;
    else
        throw  std::runtime_error("Unsupported element datatype");

    if (storageScheme == "general")
        _storage_scheme = general;
    else if (storageScheme == "symmetric")
        _storage_scheme = symmetric;
    else if (storageScheme == "hermitian")
        _storage_scheme = hermitian;
    else if (storageScheme == "skew")
        _storage_scheme = skew;
    else
        throw std::runtime_error("Unsupported storage scheme");

    //
    // Skip comment lines
    //
    std::string line;
    // skip one newline
    istr.get();
    while (istr.peek() == '%')
        getline(istr, line);

    //
    // Read size info
    //
    if (!(istr >> _rows >> _cols >> _nnz))
        throw std::runtime_error("Error reading matrix dimensions");
}

const int& MtxDataIterator::get_rows() const
{
    return _rows;
}

const int& MtxDataIterator::get_cols() const
{
    return _cols;
}

const int& MtxDataIterator::get_nnz() const
{
    return _nnz;
}

void MtxDataIterator::read_next_triplet()
{
    int row, col;
    double val;

    if (eof())
        throw std::runtime_error("Read past end of matrix data");

    if (_nnz_read < _nnz) {
        if (!((*_istr) >> row >> col >> val))
            throw std::runtime_error("Error reading matrix data");

        _triplet.row = row-1;
        _triplet.col = col-1;
        _triplet.val = val;
    }
    _nnz_read ++;
}

MtxDataIterator& MtxDataIterator::operator++()
{
    if (_iterate_mirror && !_last_mirrored && _triplet.row != _triplet.col) {
        // swap row amd column
        int temp = _triplet.row;
        _triplet.row = _triplet.col;
        _triplet.col = temp;
        if (get_storage_scheme() == skew)
            _triplet.val = -_triplet.val;
        _last_mirrored = true;
        // hermitian case not supported
    } else {
        read_next_triplet();
        _last_mirrored = false;
    }
    return *this;
}

---