sparse_matrix_factory.hpp

// FEAT3: Finite Element Analysis Toolbox, Version 3
// Copyright (C) 2010 by Stefan Turek & the FEAT group
// FEAT3 is released under the GNU General Public License version 3,
// see the file 'copyright.txt' in the top level directory for details.
 
#pragma once
 
// includes, FEAT
#include <kernel/base_header.hpp>
#include <kernel/lafem/sparse_matrix_csr.hpp>
#include <kernel/util/assertion.hpp>
 
// includes, system
#include <map>
#include <iterator>
 
 
namespace FEAT
{
  namespace LAFEM
  {
    template<typename DT_, typename IT_>
    class SparseMatrixFactory
    {
    private:
      Index _num_row;
      Index _num_col;
      static constexpr IT_ max_size = IT_(100000u);
      std::map<IT_, DT_> memory;
 
    public:
 
      explicit SparseMatrixFactory(Index num_rows, Index num_cols) :
        _num_row(num_rows), _num_col(num_cols)
      {
        XASSERTM(num_rows <= Index(max_size), "User tried to generate a Matrix with more than 100000 rows!");
        XASSERTM(num_cols <= Index(max_size), "User tried to generate a Matrix with more than 100000 colums!");
      }
 
      void add(Index i, Index j, DT_ a_ij)
      {
        ASSERTM(i < _num_row, "User tried to add input out of bounds of the matrix" );
        ASSERTM(j < _num_col, "User tried to add input out of bounds of the matrix");
        memory.emplace(IT_(i) * max_size + IT_(j), a_ij);
      }
 
      Index columns() const
      {
        return _num_col;
      }
      Index rows() const
      {
        return _num_row;
      }
      Index size() const
      {
        return _num_col*_num_row;
      }
 
      Index used_elements() const
      {
        return Index(memory.size());
      }
 
      SparseMatrixCSR<DT_, IT_> make_csr() const
      {
        //Creates CSR matrix with dimensions and number of NNZ of map.
        FEAT::LAFEM::SparseMatrixCSR<DT_, IT_ > matrix(_num_row, _num_col, Index( memory.size()));
        // pointer on the empty arrays of the CSR matrix structure
        IT_* row_ptr = matrix.row_ptr();
        IT_* col_ind = matrix.col_ind();
        DT_* val = matrix.val();
 
        row_ptr[0] = IT_(0);
        // numberNotZero elements
        IT_ _nnz = IT_(0);
        // current row count
        IT_ _row_cur = IT_(0);
 
        //Iterates over the map to extract the data and paste in the corresponding arrays.
        //typename std::map< IT_, DT_>::const_iterator  it = memory.begin();
        for(auto it = memory.begin(); it != memory.end();++it)
        {
          // extract column and row from the map key
          IT_ col = it->first % max_size;
          IT_ row = (it->first - col) / max_size;
          // make sure the row pointer is valid even if there exist preceeding empty rows in the matrix
          while (_row_cur <row )
          {
            row_ptr[++_row_cur] = _nnz;
          }
          val[_nnz] = it->second;
          col_ind[_nnz] = col;
          ++_nnz;
        }
        // make sure that the row pointer is valid even if there are empty rows at the end of the matrix
        while (_row_cur < _num_row)
        {
          row_ptr[++_row_cur] = _nnz;
        }
 
        /*// For testing Purposes: Printing the three arrays
        std::cout<<"Values: ";
        for (IT_ i = 0; i < _nzv; ++i)
        {
          std::cout << val[i] << "  ";
        }
        std::cout << "  \nColum Indizes:" ;
 
        for (IT_ i = 0; i < _nzv; ++i)
        {
          std::cout << col_ind[i] << "  ";
        }
        std::cout << "  \nRow Pointers:";
        for (IT_ i = 0; i < _num_row + 1; ++i)
        {
          std::cout << row_ptr[i] << "  ";
        }
        std::cout << " \n";
        */
        return matrix;
      }
    }; // class SparseMatrixFactory
  } // namespace LAFEM
} // namespace FEAT