/*! \file RectBlockMatrix.hpp \brief Block storage for Rectangular matrix \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_RECTBLOCKMATRIX_HPP #define _ALGEBRA_RECTBLOCKMATRIX_HPP #include #include #include #include using std::vector; template class RectBlockMatrix { public: RectBlockMatrix() { _dim_r = 0; _dim_c = 0; _block_size = 0; _block_size_last_r = 0; _block_size_last_c = 0; _num_blocks_r = 0; _num_blocks_c = 0; _deallocation_status = true; } RectBlockMatrix(int dim_r, int dim_c, int block_size) { #ifdef DEBUG_SQUAREBLOCKMATRIX fprintf(stderr, "%s %d : constructor with args %d %d\n", __FILE__, __LINE__, dim, block_size); #endif init(dim_r, dim_c, block_size, 0); allocate(); _deallocation_status = false; } RectBlockMatrix(int dim_r, int dim_c, double *aa) { #ifdef DEBUG_SQUAREBLOCKMATRIX fprintf(stderr, "%s %d : constructor with args %d %d\n", __FILE__, __LINE__, dim, block_size); #endif _block_size = dim_r > dim_c ? dim_r : dim_c; _dim_c = dim_c; _dim_r = dim_r; _num_blocks_r = 1; _num_blocks_c = 1; _coefs = new T*[1]; _coefs[0] = aa; _block_sizes_r.resize(1); _block_sizes_c.resize(1); _indexblock_r.resize(2); _indexblock_c.resize(2); _block_sizes_r[0] = _dim_r; _block_sizes_c[0] = _dim_c; _indexblock_r[0] = 0; _indexblock_r[1] = _dim_r; _indexblock_c[0] = 0; _indexblock_c[1] = _dim_c; _allocation_status = new bool[1]; _allocation_status[0] = false; // _coefs[0] is not allowed to free _isdecomposed_c = false; _deallocation_status = true; } void init(int dim_r, int dim_c, int block_size, int first_block = 0); void allocateBlock(int i, int j); void allocate(); void free(int i, int j); void free(); ~RectBlockMatrix() { free(); if (!_deallocation_status) { delete [] _coefs; delete [] _allocation_status; } _deallocation_status = true; _block_sizes_r.clear(); _block_sizes_c.clear(); _num_blocks_r = 0; // ? to avoid double free _num_blocks_c = 0; // ? to avoid double free _dim_r = 0; _dim_c = 0; } int dimension_r() const { return (int)_dim_r; } int dimension_c() const { return (int)_dim_c; } int block_size() const { return (int)_block_size; } int num_blocks_r() const { return _num_blocks_r; } int num_blocks_c() const { return _num_blocks_c; } int nbRows() const { return _dim_r; } int nbColumns() const { return _dim_c; } int block_size_last_r() const { return (int)_block_size_last_r; } int block_size_last_c() const { return (int)_block_size_last_c; } int nrowBlock(int i) const { return _block_sizes_r[i]; } int ncolBlock(int i) const { return _block_sizes_c[i]; } int IndexBlock_r(int i) const { return _indexblock_r[i]; } int IndexBlock_c(int i) const { return _indexblock_c[i]; } T* addrCoefBlock(int i, int j); void ZeroClear(); T& operator () (int i, int j); const T& operator () (int i, int j) const; RectBlockMatrix* clone() const { RectBlockMatrix *ret = new RectBlockMatrix; ret->copy(*this); return(ret); } void copy ( const RectBlockMatrix& A ) { _block_size = A._block_size; _block_size2 = A._block_size2; _num_blocks = A._num_blocks; _block_sizes_r = A._block_sizes_r; _block_sizes_c = A._block_sizes_c; _dim_r = A._dim_r; _dim_c = A._dim_c; _block_size_last_r = A._block_size_last_r; _block_size_last_c = A._block_size_last_c; _num_blocks_r = A._num_blocks_r; _num_blocks_c = A._num_blocks_c; _coefs = A._coefs; _allocation_status = A._allocation_status; _deallocation_status = A._deallocation_status; } private: int _block_size; int _block_size2; int _num_blocks; vector _block_sizes_r; vector _block_sizes_c; vector _indexblock_r; vector _indexblock_c; int _dim_r; int _dim_c; int _block_size_last_r; int _block_size_last_c; int _block_size_last0_c; int _block_size_last1_c; int _num_blocks_r; int _num_blocks_c; int _num_blocks0_c; int _num_blocks1_c; int _dim0_c; int _dim1_c; T** _coefs; bool *_allocation_status; bool _deallocation_status; bool _isdecomposed_c; }; // End class RectMatrix #endif