/*! \file SquareBlockMatrix.hpp
\brief Block storage for symmetric/unsymmetric Square 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_SQUAREBLOCKMATRIX_HPP
#define _ALGEBRA_SQUAREBLOCKMATRIX_HPP
#include
#include
#include
using std::vector;
template
class SquareBlockMatrix
{
public:
SquareBlockMatrix() : _dim(0), _size(0), _block_size(0), _block_size2(0),
_block_size_last(0), _isSym(true)
{
_isblocked = false;
_isdecomposed = false;
_num_blocks = 0;
_num_blocks0 = 0;
_num_blocks1 = 0;
_dim0 = 0;
_dim1 = 0;
_block_size_last0 = 0;
_block_size_last1 = 0;
_lower_allocated = false;
_coefs_alloc_status = false;
_pivrelaxed = false;
}
SquareBlockMatrix(int dim, int block_size, bool isSym)
{
#ifdef DEBUG_SQUAREBLOCKMATRIX
fprintf(stderr, "%s %d : constructor with args %d %d\n",
__FILE__, __LINE__, dim, block_size);
#endif
if (dim > 0) {
init(dim, block_size, isSym, 0);
allocate();
_permute.resize(dim);
}
}
void init(int dim, int block_size, bool isSym, int first_block = 0);
void allocateBlock(int i, int j);
void allocate();
void free(int i, int j);
void free();
~SquareBlockMatrix() {
free();
if (_coefs_alloc_status) {
delete [] _coefs;
delete [] _allocation_status;
_coefs_alloc_status = false;
}
_block_sizes.clear();
_nsing_block.clear();
_num_blocks = 0; // ? to avoid double free
_dim = 0;
_permute.clear();
_singIdx.clear();
_singIdx0.clear();
}
int dimension() const { return (int)_dim; }
int dimension0() const { return (int)_dim0; }
int dimension1() const { return (int)_dim1; }
int storage_size() const { return (int)_size; }
int block_size() const { return (int)_block_size; }
int num_blocks() const { return _num_blocks; }
int block_size_last() const { return (int)_block_size_last; }
bool isSym() const { return _isSym; }
bool isDecomposed() const { return _isdecomposed; }
int num_blocks0() const { return _num_blocks0; }
int num_blocks1() const { return _num_blocks1; }
int block_size_last0() const { return (int)_block_size_last0; }
int block_size_last1() const { return (int)_block_size_last1; }
int nrowBlock(int i) const { return _block_sizes[i]; }
// int offsetBlock(int i, int j) const;
T** coefs() { return _coefs; }
T* addrCoefBlock(int i, int j);
void allocateLowerBlocks() {
if ((!_lower_allocated) && _isSym) {
for (int i = 0; i < _num_blocks; i++) {
for (int j = 0; j < i; j++) {
const int nrow = _block_sizes[i];
const int ncol = _block_sizes[j];
const int itmp = i + j * _num_blocks;
_coefs[itmp] = new T[nrow * ncol];
_allocation_status[itmp] = true;
}
}
_lower_allocated = true;
}
}
void freeLowerBlocks() {
#ifdef ALLOCATE_LOWER_BLOCKS
if (_lower_allocated && _isSym) {
#else
if (_isSym) {
#endif
for (int i = 0; i < _num_blocks; i++) {
for (int j = 0; j < i; j++) {
const int itmp = i + j * _num_blocks;
if (_allocation_status[itmp]) {
delete [] _coefs[itmp];
}
_allocation_status[itmp] = false;
}
}
_lower_allocated = false;
}
else {
fprintf(stderr, "double free _lower %s %d\n", __FILE__, __LINE__);
}
}
int nrowBlock(int i, int j) const
{
return (i <= j ? _block_sizes[i] : _block_sizes[j]);
}
int ncolBlock(int i, int j) const
{
return (i <= j ? _block_sizes[j] : _block_sizes[i]);
}
bool isTransposed(int i, int j);
int BlockIndex(int i) const {
int iblock;
if (_isdecomposed) {
if (i < _dim0) {
iblock = i / _block_size;
}
else {
iblock = (i - _dim0) / _block_size + _num_blocks0;
}
}
else {
iblock = i / _block_size;
}
return iblock;
}
int IndexBlock(int iblock) {
int index;
if (_isdecomposed) {
if (iblock < _num_blocks0) {
index = iblock * _block_size;
}
else {
index = _dim0 + (iblock - _num_blocks0) * _block_size;
}
}
else {
index = iblock * _block_size;
}
return index;
}
int BlockOffset(int i) const {
int ires;
if (_isdecomposed) {
if (i < _dim0) {
ires = i % _block_size;
}
else {
ires = (i - _dim0) % _block_size;
}
}
else {
ires = i % _block_size;
}
return ires;
}
void copyFromArrayPermute(const T *a, int dim, int *permute);
void copyFromArray(const T *a, int dim);
void copyToArrayFull(const T *a,int dim);
void copyBlockToArray(int i, int j, const T *a,int dim);
void ZeroClear();
T& diag(int i);
const T& diag(int i) const;
T& operator () (int i, int j);
const T& operator () (int i, int j) const;
SquareBlockMatrix* clone() const
{
SquareBlockMatrix *ret = new SquareBlockMatrix;
ret->copy(*this);
return(ret);
}
void copy ( const SquareBlockMatrix& A )
{
// PlainMatrix::copy(A); //_loc2glob=A._loc2glob;
_block_size = A._block_size;
_block_size2 = A._block_size2;
_num_blocks = A._num_blocks;
_block_size_last = A._block_size_last;
_isSym = A._isSym;
_rank = A._rank;
_nsing = A._nsing;
_nsing_block = A._nsing_block;
_dim = A._dim;
_size = A._size;
_permute = A._permute;
_kernelDetected = A._kernelDetected;
_singIdx = A._singIdx;
_singIdx0 = A._singIdx0;
_isblocked = A._isblocked;
}
bool isBlocked()
{
return _isblocked;
}
void unsetBlocked()
{
_isblocked = false;
}
void setBlocked()
{
_isblocked = true;
}
void set_rank(int rank) {
_rank = rank;
_nsing = _dim - _rank;
}
void set_KernelDetected(int state) {
_kernelDetected = state;
}
int KernelDetected() const {
return _kernelDetected;
}
vector &getNsingBlock() {
return _nsing_block;
}
vector &getSingIdx() {
return _singIdx;
}
vector &getSingIdx0() {
return _singIdx0;
}
int rank() const
{
return _rank;
}
int dim_kern() const
{
return _nsing;
}
void set_dim_kern(int nsing)
{ _nsing = nsing; }
int dim_kern_block(int k) const
{
return _nsing_block[k];
}
void set_dim_kern_block(int k, int nsing)
{
_nsing_block[k] = nsing;
}
vector& getPermute()
{
return _permute;
}
const vector& getPermute() const
{
return _permute;
}
void set_lastPivot(double lastpiv)
{
_lastpiv = lastpiv;
}
double lastPivot() const
{
# ifdef DISDEBUG
assert( isFactorized() );
# endif
return _lastpiv;
}
void unset_pivrelaxed() { _pivrelaxed = false; }
void set_pivrelaxed() { _pivrelaxed = true; }
bool is_pivrelaxed() { return _pivrelaxed; }
private:
int _dim; // _block_sizes;
int _dim0;
int _dim1;
int _block_size_last0;
int _block_size_last1;
int _num_blocks0;
int _num_blocks1;
bool _isdecomposed;
//
bool _coefs_alloc_status;
bool *_allocation_status;
bool _lower_allocated;
//
int _rank; //!< Rank of the matrix (initialized after factorization)
int _nsing;
double _lastpiv; // in case of quadruple ?
T** _coefs;
//
bool _isblocked;
vector _nsing_block;
vector _permute;
bool _kernelDetected; // true : done, false : unknown
vector _singIdx; // with permutation
vector _singIdx0; // without permutation
bool _pivrelaxed;
//
}; // End class SquareMatrix
#endif