matrix.h

Go to the documentation of this file.

// This file is part of HermesCommon
//
// Copyright (c) 2009 hp-FEM group at the University of Nevada, Reno (UNR).
// Email: hpfem-group@unr.edu, home page: http://www.hpfem.org/.
//
// Hermes2D 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.
//
// Hermes2D is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Hermes2D; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#ifndef __HERMES_COMMON_MATRIX_H
#define __HERMES_COMMON_MATRIX_H

#include "algebra_utilities.h"
#include "algebra_mixins.h"
#include "mixins.h"

namespace Hermes
{
  namespace Algebra
  {
    template<typename Scalar>
    class HERMES_API Matrix : public Hermes::Mixins::Loggable, public Algebra::Mixins::MatrixRhsImportExport < Scalar >
    {
    public:
      Matrix(unsigned int size = 0);
      virtual ~Matrix() {};

      virtual void alloc() = 0;

      virtual void free() = 0;

      virtual Scalar get(unsigned int m, unsigned int n) const = 0;

      virtual void zero() = 0;

      virtual void set_row_zero(unsigned int n);

      virtual void add(unsigned int m, unsigned int n, Scalar v) = 0;

      virtual void add(unsigned int m, unsigned int n, Scalar *mat, int *rows, int *cols, const int size);

      virtual void add_to_diagonal(Scalar v);

      virtual void multiply_with_vector(Scalar* vector_in, Scalar*& vector_out, bool vector_out_initialized = false) const;

      virtual void multiply_with_Scalar(Scalar value);

      virtual unsigned int get_size() const;

    protected:
      unsigned int size;
    };

    template<typename Scalar>
    class HERMES_API SparseMatrix : public Matrix < Scalar > {
    public:
      SparseMatrix();
      SparseMatrix(unsigned int size);
      virtual ~SparseMatrix();

      virtual void prealloc(unsigned int n);

      virtual void free();

      virtual void pre_add_ij(unsigned int row, unsigned int col);

      virtual void finish();

      virtual void add_sparse_matrix(SparseMatrix<Scalar>* mat);

      virtual void add_sparse_to_diagonal_blocks(int num_stages, SparseMatrix<Scalar>* mat);

      virtual void add_as_block(unsigned int i, unsigned int j, SparseMatrix<Scalar>* mat);

      virtual int get_num_row_entries(unsigned int row) const;

      virtual void extract_row_copy(unsigned int row, unsigned int len,
        unsigned int &n_entries, double *vals, unsigned int *idxs) const;

      virtual int get_num_col_entries(unsigned int col) const;

      virtual void extract_col_copy(unsigned int col, unsigned int len,
        unsigned int &n_entries, double *vals, unsigned int *idxs) const;

      virtual SparseMatrix<Scalar>* duplicate() const;

      virtual double get_fill_in() const = 0;

      virtual unsigned int get_nnz() const;

    protected:
      static const int PAGE_SIZE = 100;

      struct Page {
        Page(bool dyn_stored_ = false) : dyn_stored(dyn_stored_), next(nullptr), count(0) {
        };
        unsigned char count;
        int idx[PAGE_SIZE];
        Page *next;
        bool dyn_stored;
      };

      Page *pages;
      Page **next_pages;

      int sort_and_store_indices(Page *page, int *buffer, int *max);
      int get_num_indices();
    };

    template<typename Scalar> HERMES_API
      SparseMatrix<Scalar>*  create_matrix(bool use_direct_solver = false);
  }
}
#endif