matrixindexset.hh

// SPDX-FileCopyrightText: Copyright (C) DUNE Project contributors, see file LICENSE.md in module root
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_ISTL_MATRIXINDEXSET_HH
#define DUNE_ISTL_MATRIXINDEXSET_HH
 
#include <vector>
#include <set>
 
namespace Dune {
 
 
  class MatrixIndexSet
  {
 
  public:
    typedef std::size_t size_type;
 
    MatrixIndexSet() : rows_(0), cols_(0)
    {}
 
    MatrixIndexSet(size_type rows, size_type cols) : rows_(rows), cols_(cols) {
      indices_.resize(rows_);
    }
 
    void resize(size_type rows, size_type cols) {
      rows_ = rows;
      cols_ = cols;
      indices_.resize(rows_);
    }
 
    void add(size_type i, size_type j) {
      indices_[i].insert(j);
    }
 
    size_type size() const {
      size_type entries = 0;
      for (size_type i=0; i<rows_; i++)
        entries += indices_[i].size();
 
      return entries;
    }
 
    size_type rows() const {return rows_;}
 
 
    size_type rowsize(size_type row) const {return indices_[row].size();}
 
    template <class MatrixType>
    void import(const MatrixType& m, size_type rowOffset=0, size_type colOffset=0) {
 
      typedef typename MatrixType::row_type RowType;
      typedef typename RowType::ConstIterator ColumnIterator;
 
      for (size_type rowIdx=0; rowIdx<m.N(); rowIdx++) {
 
        const RowType& row = m[rowIdx];
 
        ColumnIterator cIt    = row.begin();
        ColumnIterator cEndIt = row.end();
 
        for(; cIt!=cEndIt; ++cIt)
          add(rowIdx+rowOffset, cIt.index()+colOffset);
 
      }
 
    }
 
    template <class MatrixType>
    void exportIdx(MatrixType& matrix) const {
 
      matrix.setSize(rows_, cols_);
      matrix.setBuildMode(MatrixType::random);
 
      for (size_type i=0; i<rows_; i++)
        matrix.setrowsize(i, indices_[i].size());
 
      matrix.endrowsizes();
 
      for (size_type i=0; i<rows_; i++) {
 
        typename std::set<size_type>::iterator it = indices_[i].begin();
        for (; it!=indices_[i].end(); ++it)
          matrix.addindex(i, *it);
 
      }
 
      matrix.endindices();
 
    }
 
  private:
 
    std::vector<std::set<size_type> > indices_;
 
    size_type rows_, cols_;
 
  };
 
 
} // end namespace Dune
 
#endif