/*! \file PlainMatrix.hpp \brief Common interface for plain matrices (square, rectangulars,...) \author Xavier Juvigny, ONERA \date Jan. 25th 2005 \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_PLAINMATRIX_ # define _ALGEBRA_PLAINMATRIX_ #include #include #include //#define DEBUG_MEMORY_PLAINMATRIX #ifdef DEBUG_MEMORY_PLAINMATRIX # include #include #endif template class PlainMatrix { public: PlainMatrix(bool isOwner = true) { _isOwner = isOwner; _n = (-1); // not yet allocated _coefs = new T*; _coefs_alloc_status = true; } PlainMatrix(int nbElts) { _isOwner = true; _n = nbElts; _coefs = new T*; _coefs_alloc_status = true; try { *_coefs = new T[nbElts]; } catch (const std::bad_alloc& e) { fprintf(stderr, "%s %d : allocation failed : %s", __FILE__, __LINE__, e.what()); } #ifdef DEBUG_MEMORY_PLAINMATRIX mem_get(); fprintf(stderr, "@@PlainMatrix constructor : %.6e %.6e @%x %d\n", (double)_mem_vrt * 4.0 / (1024.0 *1024.0), (double)_mem_res * 4.0 / (1024.0 *1024.0), *_coefs, (sizeof(T) * nbElts)); #endif } virtual ~PlainMatrix() { free(); if (_coefs_alloc_status) { delete _coefs; // same as destructor _coefs_alloc_status = false; } } #ifdef DEBUG_MEMORY_PLAINMATRIX void mem_get() { int pid = (int)getpid(); // cerr << "pid = " << pid << endl; char buf[256]; sprintf(buf, "/proc/%d/statm", pid); ifstream fin(buf); fin >> _mem_vrt >> _mem_res; fin.close(); } #endif int size() const { return _n; } inline T& operator [] (int i) { return (*_coefs)[i]; } inline const T& operator [] (int i) const { return (*_coefs)[i]; } virtual T& operator () (int i, int j) = 0; virtual const T& operator () (int i, int j) const = 0; T** addrCoefs_pt() { return _coefs; } const T** addrCoefs_pt() const { return _coefs; } inline T* addrCoefs() { return *_coefs; } inline const T* addrCoefs() const { return *_coefs; } protected: void init(int nbElts) { _isOwner = true; if (_n == (-1)) { _n = nbElts; if (_n > 0) { try { *_coefs = new T[nbElts]; } catch (const std::bad_alloc& e) { fprintf(stderr, "%s %d : allocation failed : %s", __FILE__, __LINE__, e.what()); } #ifdef DEBUG_MEMORY_PLAINMATRIX mem_get(); fprintf(stderr, "@@PlainMatrix init : %.6e %.6e %d\n", (double)_mem_vrt * 4.0 / (1024.0 *1024.0), (double)_mem_res * 4.0 / (1024.0 *1024.0), (sizeof(T) * nbElts)); #endif } } // _n == (-1) else { #if 0 if (_n > nbElts) { fprintf(stderr, "%s %d : PlanMatrix::init(%d) : %d better deallocate %d\n", __FILE__, __LINE__, nbElts, _n, (_n - nbElts)); } #endif delete [] *_coefs; try { *_coefs = new T[nbElts]; } catch (const std::bad_alloc& e) { fprintf(stderr, "%s %d : allocation failed : %s", __FILE__, __LINE__, e.what()); } _n = nbElts; } } void init(int nbElts, T* coefs, bool isOwner) { _isOwner = isOwner; _n = nbElts; *_coefs = coefs; } void free() { if (_n > 0 && _isOwner) { #ifdef DEBUG_MEMORY_PLAINMATRIX mem_get(); fprintf(stderr, "@@PlainMatrix free : %.6e %.6e @%x\n", (double)_mem_vrt * 4.0 / (1024.0 *1024.0), (double)_mem_res * 4.0 / (1024.0 *1024.0), *_coefs); #endif delete [] *_coefs; } _n = (-1); } T* coefs() { return *_coefs; } const T* coefs() const { return *_coefs; } void ZeroClear() { #if 0 const T zero(0.0); for (int i = 0; i < _n; i++) { (*_coefs)[i] = zero; // memset() } #else memset((void *)*_coefs, 0, sizeof(T) * _n); #endif } virtual PlainMatrix* clone() const = 0; void copy(const PlainMatrix &M) { if (_n <= 0) { try { *_coefs = new T[_n]; } catch (const std::bad_alloc& e) { fprintf(stderr, "%s %d : allocation failed : %s", __FILE__, __LINE__, e.what()); } } _isOwner = M._isOwner; _n = M._n; #ifdef DEBUG_MEMORY_PLAINMATRIX mem_get(); fprintf(stderr, "@@PlainMatrix copy : %.6e %.6e @%x %d\n", (double)_mem_vrt * 4.0 / (1024.0 *1024.0), (double)_mem_res * 4.0 / (1024.0 *1024.0), *_coefs, (sizeof(T) * _n)); #endif #if 0 for (int i = 0; i < _n; i++) { (*_coefs)[i] = (*(M._coefs))[i]; // memcopy } #else memcpy((void *)*_coefs, (void *)*(M._coefs), _n * sizeof(T)); #endif } PlainMatrix(const PlainMatrix& A) { _isOwner = A._isOwner; _n = A._n; _coefs = A._coefs; } PlainMatrix& operator = (const PlainMatrix& A) { if (this != &A) { _isOwner = A._isOwner; _n = A._n; _coefs = A._coefs; } return *this; } private: bool _isOwner; bool _coefs_alloc_status; T** _coefs; int _n; #ifdef DEBUG_MEMORY_PLAINMATRIX uint64_t _mem_vrt, _mem_res; #endif }; // end class PlainMatrix #endif