/*! \file SparseMatrix.hpp
\brief Sparse matrix definition
\author Xavier Juvigny, ONERA
\date Jan. 25th 2005
\modification allocation of array by STL vector class
\author Atsushi Suzuki, Laboratoire Jacques-Louis Lions
\date Jun. 11th 2013
\date Jul. 12th 2015
\date Nov. 30th 2016
*/
// This file is part of Dissection
//
// Dissection 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 3 of the License, or
// (at your option) any later version.
//
// Linking Dissection statically or dynamically with other modules is making
// a combined work based on Disssection. Thus, the terms and conditions of
// the GNU General Public License cover the whole combination.
//
// As a special exception, the copyright holders of Dissection give you
// permission to combine Dissection program with free software programs or
// libraries that are released under the GNU LGPL and with independent modules
// that communicate with Dissection solely through the Dissection-fortran
// interface. You may copy and distribute such a system following the terms of
// the GNU GPL for Dissection and the licenses of the other code concerned,
// provided that you include the source code of that other code when and as
// the GNU GPL requires distribution of source code and provided that you do
// not modify the Dissection-fortran interface.
//
// Note that people who make modified versions of Dissection are not obligated
// to grant this special exception for their modified versions; it is their
// choice whether to do so. The GNU General Public License gives permission to
// release a modified version without this exception; this exception also makes
// it possible to release a modified version which carries forward this
// exception. If you modify the Dissection-fortran interface, this exception
// does not apply to your modified version of Dissection, and you must remove
// this exception when you distribute your modified version.
//
// This exception is an additional permission under section 7 of the GNU
// General Public License, version 3 ("GPLv3")
//
// Dissection 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 Dissection. If not, see .
//
#ifndef _ALGEBRA_SPARSEMATRIX_HPP_
#define _ALGEBRA_SPARSEMATRIX_HPP_
#include
#include "Compiler/blas.hpp"
using std::vector;
template
class SparseMatrix
{
public:
SparseMatrix() : _isSymmetric(false), _isUpper(true), _isWhole(false) {}
SparseMatrix(bool isSym, bool isUpper = true, bool isWhole = false) :
_isSymmetric(isSym), _isUpper(isUpper), _isWhole(isWhole)
{}
SparseMatrix( int n, int nnz, const T* coefs,
bool isSym = false,
bool isUpper = true,
bool isWhole = false) :
_isSymmetric(isSym), _isUpper(isUpper), _isWhole(isWhole)
{
_ptRows.resize(n+1);
_indCols.resize(nnz);
_coefs.resize(nnz);
for (int i = 0 ; i < nnz; i++) {
_coefs[i] = coefs[i];
}
}
// added by Atsushi, 01 Feb.2013 : symbolic data are given by integer arrays
SparseMatrix( int n, int nnz, const int *ptRows, const int *indCols,
bool isSym = false, bool isUpper = true,
bool isWhole = false) :
_isSymmetric(isSym),
_isUpper(isUpper),
_isWhole(isWhole)
{
_ptRows.resize(n+1);
for (int i = 0; i < (n + 1); i++) {
_ptRows[i] = ptRows[i];
}
_indCols.resize(nnz);
for (int i = 0; i < nnz; i++) {
_indCols[i] = indCols[i];
}
_coefs.resize(nnz);
}
SparseMatrix( int n, int nnz,
const long long int *ptRows64,
const long long int *indCols64,
bool isSym = false, bool isUpper = true,
bool isWhole = false) :
_isSymmetric(isSym),
_isUpper(isUpper),
_isWhole(isWhole)
{
_ptRows.resize(n+1);
for (int i = 0; i < (n + 1); i++) {
_ptRows[i] = ptRows64[i];
}
_indCols.resize(nnz);
for (int i = 0; i < nnz; i++) {
_indCols[i] = indCols64[i];
}
_coefs.resize(nnz);
}
SparseMatrix( int n, int nnz, const vector& ptRows,
bool isSym = false,
bool isUpper = true,
bool isWhole = false) :
_isSymmetric(isSym), _isUpper(isUpper), _isWhole(isWhole)
{
_indCols.resize(nnz);
_ptRows.resize(n + 1);
for (int i = 0; i < (n + 1); i++) {
_ptRows[i] = ptRows[i];
}
_coefs.resize(nnz);
}
SparseMatrix( const SparseMatrix& A ) :
_ptRows(A._ptRows), _indCols(A._indCols), _coefs(A._coefs),
_isSymmetric(A._isSymmetric), _isUpper(A._isUpper), _isWhole(A._isWhole)
{ }
~SparseMatrix() { free(); }
void free() {
_ptRows.clear();
_indCols.clear();
_coefs.clear();
}
inline int dimension() const { return (_ptRows.size() - 1); }
inline int nnz() const { return _indCols.size(); }
inline bool isSymmetric() const { return _isSymmetric; }
inline bool isUpper() const { return _isUpper; }
inline bool isWhole() const { return _isWhole; }
//
inline int *getRows() { return &_ptRows[0]; }
//
inline int *getIndCols() { return &_indCols[0]; }
inline T* getCoef() { return &_coefs[0]; }
inline T* getCoef() const { return &_coefs[0]; }
inline int ptRow(int i) const { return _ptRows[i]; }
inline int indCol(int i) const { return _indCols[i]; }
inline int& indCol(int i) { return _indCols[i]; }
inline const T Coef(int i) const { return _coefs[i]; }
inline T& Coef(int i) { return _coefs[i]; }
inline vector& ptRows() { return _ptRows; }
inline vector& indCols() { return _indCols; }
inline vector & coefs() { return _coefs; }
void prod(const T *u, T *v) const;
void prodt(const T *u, T *v ) const;
// void normalize(const int type, const W* coefs0, Z* precDiag);
void extractSquareMatrix(T *DSsingCofes, vector &singVal);
SparseMatrix* PartialCopyCSR(vector &permute, const int n,
bool transposed);
private:
SparseMatrix& operator = ( const SparseMatrix& A );
vector _ptRows;
vector _indCols;
vector _coefs;
bool _isSymmetric;
bool _isUpper;
bool _isWhole;
}; // End class SparseMatrix
template void
normalize(const int type, const T* coefs0, SparseMatrix *ptDA, U* u);
int CSR_sym2unsym(int *ptRows, int *indCols, int *toSym,
const int *ptSymRows, const int *indSymCols,
const int dim, const bool upper_flag);
#endif