/*! \file SquareBlockMatrix.cpp \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 . // #include "Algebra/SquareBlockMatrix.hpp" #include "Compiler/blas.hpp" // #include is inside template void SquareBlockMatrix::init(int dim, int block_size, bool isSym, int first_block) { int itmp; _pivrelaxed = false; _coefs_alloc_status = false; // for safty _dim = dim; _block_size = block_size; _isSym = isSym; _block_size2 = _block_size * _block_size; if (dim == 0) { _isblocked = true; _kernelDetected = false; _lower_allocated = false; _coefs = NULL; _coefs_alloc_status = false; _allocation_status = NULL; return; } if (first_block > 0) { _isdecomposed = true; _dim0 = first_block; _dim1 = _dim - _dim0; _num_blocks0 = (_dim0 + _block_size - 1) / _block_size; _num_blocks1 = (_dim1 + _block_size - 1) / _block_size; _num_blocks = _num_blocks0 + _num_blocks1; _block_sizes.resize(_num_blocks); itmp = _dim0 % _block_size; _block_size_last0 = (itmp == 0) ? _block_size : itmp; itmp = _dim1 % _block_size; _block_size_last1 = (itmp == 0) ? _block_size : itmp; for (int i = 0; i < (_num_blocks0 - 1); i++) { _block_sizes[i] = _block_size; } _block_sizes[_num_blocks0 - 1] = _block_size_last0; if (_num_blocks1 > 0) { for (int i = _num_blocks0; i < (_num_blocks - 1); i++) { _block_sizes[i] = _block_size; } _block_sizes[_num_blocks - 1] = _block_size_last1; } else { _block_size_last1 = 0; } } else { _isdecomposed = false; _num_blocks = (_dim + _block_size - 1) / _block_size; _block_sizes.resize(_num_blocks); itmp = _dim % _block_size; _block_size_last = (itmp == 0) ? _block_size : itmp; for (int i = 0; i < (_num_blocks - 1); i++) { _block_sizes[i] = _block_size; } _block_sizes[_num_blocks - 1] = _block_size_last; } _nsing_block.resize(_num_blocks); if (_num_blocks > 0) { for (int i = 0; i < _num_blocks; i++) { _nsing_block[i] = 0; } } _isblocked = true; _kernelDetected = false; _lower_allocated = false; if (_num_blocks > 0) { try { _coefs = new T*[_num_blocks * _num_blocks]; // need to be managed } catch (const std::bad_alloc& e) { fprintf(stderr, "%s %d : allocation failed : %s", __FILE__, __LINE__, e.what()); } try { _allocation_status = new bool[_num_blocks * _num_blocks]; } catch (const std::bad_alloc& e) { fprintf(stderr, "%s %d : allocation failed : %s", __FILE__, __LINE__, e.what()); } _coefs_alloc_status = true; for (int i = 0; i < (_num_blocks * _num_blocks); i++) { _allocation_status[i] = false; } if (_isSym) { _size = 0; for (int i = 0; i < _num_blocks; i++) { for (int j = i; j < _num_blocks; j++) { _size += _block_sizes[i] * _block_sizes[j]; } } } else { _size = 0; for (int i = 0; i < _num_blocks; i++) { for (int j = 0; j < _num_blocks; j++) { _size += _block_sizes[i] * _block_sizes[j]; } } } } else { _coefs = NULL; _coefs_alloc_status = false; _allocation_status = NULL; } } template void SquareBlockMatrix::init(int dim, int block_size, bool isSym, int first_block); template void SquareBlockMatrix::init(int dim, int block_size, bool isSym, int first_block); template void SquareBlockMatrix >::init(int dim, int block_size, bool isSym, int first_block); template void SquareBlockMatrix >::init(int dim, int block_size, bool isSym, int first_block); template void SquareBlockMatrix::init(int dim, int block_size, bool isSym, int first_block); template void SquareBlockMatrix >::init(int dim, int block_size, bool isSym, int first_block); // template void SquareBlockMatrix::allocateBlock(int i, int j) { const int nrow = _block_sizes[i]; const int ncol = _block_sizes[j]; const int itmp = i + j * _num_blocks; if (!_allocation_status[itmp]) { try { _coefs[itmp] = new T[nrow * ncol]; } catch (const std::bad_alloc& e) { fprintf(stderr, "%s %d : allocation failed : %s", __FILE__, __LINE__, e.what()); } _allocation_status[itmp] = true; } } template void SquareBlockMatrix::allocateBlock(int i, int j); template void SquareBlockMatrix::allocateBlock(int i, int j); template void SquareBlockMatrix >::allocateBlock(int i, int j); template void SquareBlockMatrix >::allocateBlock(int i, int j); template void SquareBlockMatrix::allocateBlock(int i, int j); template void SquareBlockMatrix >::allocateBlock(int i, int j); // template void SquareBlockMatrix::allocate() { if (_isSym) { // int ioffset = 0; for (int i = 0; i < _num_blocks; i++) { for (int j = i; j < _num_blocks; j++) { const int nrow = _block_sizes[i]; const int ncol = _block_sizes[j]; const int itmp = i + j * _num_blocks; if (!_allocation_status[itmp]) { try { _coefs[itmp] = new T[nrow * ncol]; } catch (const std::bad_alloc& e) { fprintf(stderr, "%s %d : allocation failed : %s", __FILE__, __LINE__, e.what()); } } _allocation_status[itmp] = true; } } } else { // int ioffset = 0; for (int i = 0; i < _num_blocks; i++) { for (int j = 0; j < _num_blocks; j++) { const int nrow = _block_sizes[i]; const int ncol = _block_sizes[j]; const int itmp = i + j * _num_blocks; if (!_allocation_status[itmp]) { try { _coefs[itmp] = new T[nrow * ncol]; } catch (const std::bad_alloc& e) { fprintf(stderr, "%s %d : allocation failed : %s", __FILE__, __LINE__, e.what()); } } _allocation_status[itmp] = true; } } } } template void SquareBlockMatrix::allocate(); template void SquareBlockMatrix::allocate(); template void SquareBlockMatrix >::allocate(); template void SquareBlockMatrix >::allocate(); template void SquareBlockMatrix::allocate(); template void SquareBlockMatrix >::allocate(); // template void SquareBlockMatrix::free(int i, int j) { const int itmp = i + j * _num_blocks; if (_allocation_status[itmp]) { delete [] _coefs[itmp]; // need to be mananged } _allocation_status[itmp] = false; } template void SquareBlockMatrix::free(int i, int j); template void SquareBlockMatrix::free(int i, int j); template void SquareBlockMatrix >::free(int i, int j); template void SquareBlockMatrix >::free(int i, int j); template void SquareBlockMatrix::free(int i, int j); template void SquareBlockMatrix >::free(int i, int j); // template void SquareBlockMatrix::free() { if (_isSym) { for (int i = 0; i < _num_blocks; i++) { for (int j = i; j < _num_blocks; j++) { const int itmp = i + j * _num_blocks; if (_allocation_status[itmp]) { delete [] _coefs[itmp]; // need to be mananged } _allocation_status[itmp]= false; } } } else { for (int i = 0; i < _num_blocks; i++) { for (int j = 0; j < _num_blocks; j++) { const int itmp = i + j * _num_blocks; if (_allocation_status[itmp]) { delete [] _coefs[itmp]; // need to be managed } _allocation_status[itmp] = false; } } } } template void SquareBlockMatrix::free(); template void SquareBlockMatrix::free(); template void SquareBlockMatrix >::free(); template void SquareBlockMatrix >::free(); template void SquareBlockMatrix::free(); template void SquareBlockMatrix >::free(); // template T* SquareBlockMatrix::addrCoefBlock(int i, int j) { if (_isdecomposed) { // is necessary? if (_isSym && (i > j)) { return _coefs[j + i * _num_blocks]; } } return _coefs[i + j * _num_blocks]; } template double* SquareBlockMatrix::addrCoefBlock(int i, int j); template quadruple* SquareBlockMatrix::addrCoefBlock(int i, int j); template complex* SquareBlockMatrix >:: addrCoefBlock(int i, int j); template complex* SquareBlockMatrix >:: addrCoefBlock(int i, int j); template float* SquareBlockMatrix::addrCoefBlock(int i, int j); template complex* SquareBlockMatrix >:: addrCoefBlock(int i, int j); // template void SquareBlockMatrix::ZeroClear() { const T zero(0.0); if (_isSym) { for (int i = 0; i < _num_blocks; i++) { for (int j = i; j < _num_blocks; j++) { const int nrow = _block_sizes[i]; const int ncol = _block_sizes[j]; const int nsize = nrow * ncol; const int itmp = i + j * _num_blocks; for (int k = 0; k < nsize; k++) { _coefs[itmp][k] = zero; // needs to be replaced by memcpy } } } } else { for (int i = 0; i < _num_blocks; i++) { for (int j = 0; j < _num_blocks; j++) { const int nrow = _block_sizes[i]; const int ncol = _block_sizes[j]; const int nsize = nrow * ncol; const int itmp = i + j * _num_blocks; for (int k = 0; k < nsize; k++) { _coefs[itmp][k] = zero; // needs to be replaced by memcpy } } } } } template void SquareBlockMatrix::ZeroClear(); template void SquareBlockMatrix::ZeroClear(); template void SquareBlockMatrix >::ZeroClear(); template void SquareBlockMatrix >::ZeroClear(); template void SquareBlockMatrix::ZeroClear(); template void SquareBlockMatrix >::ZeroClear(); // template T& SquareBlockMatrix::diag(int i) { int i0, i1; if(_isdecomposed) { fprintf(stderr, "%s %d : operator() is not suppoesd to be used\n", __FILE__, __LINE__); i0 = BlockIndex(i); i1 = BlockOffset(i); } else { i0 = i / _block_size; i1 = i % _block_size; } // const int itmp = offsetBlock(i0, i0) + i1 * (nrowBlock(i0, i0) + 1); // return coefs()[itmp]; return _coefs[i0 * (_num_blocks + 1)][i1 * (nrowBlock(i0, i0) + 1)]; } template double& SquareBlockMatrix::diag(int i); template quadruple& SquareBlockMatrix::diag(int i); template complex & SquareBlockMatrix >::diag(int i); template complex & SquareBlockMatrix >::diag(int i); template float& SquareBlockMatrix::diag(int i); template complex & SquareBlockMatrix >::diag(int i); // template const T& SquareBlockMatrix::diag(int i) const { int i0, i1; if(_isdecomposed) { fprintf(stderr, "%s %d : operator() is not suppoesd to be used\n", __FILE__, __LINE__); i0 = BlockIndex(i); i1 = BlockOffset(i); } else { i0 = i / _block_size; i1 = i % _block_size; } return _coefs[i0 * (_num_blocks + 1)][i1 * (nrowBlock(i0, i0) + 1)]; } template const double & SquareBlockMatrix::diag(int i) const; template const quadruple & SquareBlockMatrix::diag(int i) const; template const complex & SquareBlockMatrix >::diag(int i) const; template const complex & SquareBlockMatrix >:: diag(int i) const; template const float & SquareBlockMatrix::diag(int i) const; template const complex & SquareBlockMatrix >::diag(int i) const; // template T& SquareBlockMatrix::operator () (int i, int j) { int i0, i1, j0, j1; if(_isdecomposed) { fprintf(stderr, "%s %d : operator() is not suppoesd to be used\n", __FILE__, __LINE__); if (_isSym) { if (i < j) { i0 = BlockIndex(i); j0 = BlockIndex(j); i1 = BlockOffset(i); j1 = BlockOffset(j); } else { i0 = BlockIndex(j); j0 = BlockIndex(i); i1 = BlockOffset(j); j1 = BlockOffset(i); } } else { i0 = BlockIndex(i); j0 = BlockIndex(j); if(i0 > j0) { i1 = BlockOffset(j); j1 = BlockOffset(i); } else { i1 = BlockOffset(i); j1 = BlockOffset(j); } } } // if(_isdecomposed) { else { if (_isSym) { if (i < j) { i0 = i / _block_size; i1 = i % _block_size; j0 = j / _block_size; j1 = j % _block_size; } else { i0 = j / _block_size; i1 = j % _block_size; j0 = i / _block_size; j1 = i % _block_size; } } else { i0 = i / _block_size; j0 = j / _block_size; if (i0 > j0) { i1 = j % _block_size; j1 = i % _block_size; } else { i1 = i % _block_size; j1 = j % _block_size; } } } // if(_isdecomposed) else return _coefs[i0 + j0 * _num_blocks][i1 + j1 * nrowBlock(i0, j0)]; } template double& SquareBlockMatrix::operator () (int i, int j); template quadruple& SquareBlockMatrix::operator () (int i, int j); template complex & SquareBlockMatrix >:: operator () (int i, int j); template complex & SquareBlockMatrix >:: operator () (int i, int j); template float& SquareBlockMatrix::operator () (int i, int j); template complex & SquareBlockMatrix >:: operator () (int i, int j); // template const T& SquareBlockMatrix::operator () (int i, int j) const { int i0, i1, j0, j1; if(_isdecomposed) { fprintf(stderr, "%s %d : operator() is not suppoesd to be used\n", __FILE__, __LINE__); if (_isSym) { if (i < j) { i0 = BlockIndex(i); j0 = BlockIndex(j); i1 = BlockOffset(i); j1 = BlockOffset(j); } else { i0 = BlockIndex(j); j0 = BlockIndex(i); i1 = BlockOffset(j); j1 = BlockOffset(i); } } else { i0 = BlockIndex(i); j0 = BlockIndex(j); if(i0 > j0) { i1 = BlockOffset(j); j1 = BlockOffset(i); } else { i1 = BlockOffset(i); j1 = BlockOffset(j); } } } // if(_isdecomposed) { else { if (_isSym) { if (i < j) { i0 = i / _block_size; i1 = i % _block_size; j0 = j / _block_size; j1 = j % _block_size; } else { i0 = j / _block_size; i1 = j % _block_size; j0 = i / _block_size; j1 = i % _block_size; } } else { i0 = i / _block_size; j0 = j / _block_size; if (i0 > j0) { i1 = j % _block_size; j1 = i % _block_size; } else { i1 = i % _block_size; j1 = j % _block_size; } } } // if(_isdecomposed) else return _coefs[i0 + j0 * _num_blocks][i1 + j1 * nrowBlock(i0, j0)]; } template const double& SquareBlockMatrix::operator () (int i, int j) const; template const quadruple& SquareBlockMatrix::operator () (int i, int j) const; template const complex& SquareBlockMatrix >:: operator () (int i, int j) const; template const complex& SquareBlockMatrix >:: operator () (int i, int j) const; template const float& SquareBlockMatrix::operator () (int i, int j) const; template const complex& SquareBlockMatrix >:: operator () (int i, int j) const; // template void SquareBlockMatrix::copyFromArray(const T *a, int dim) { if (_isdecomposed) { fprintf(stderr, "%s %d : copyFromArray() cannot copy decompesd data\n", __FILE__, __LINE__); return; } if (dim != _dim) { fprintf(stderr, "%s %d : mismatched dim %d != %d\n", __FILE__, __LINE__, dim, _dim); return; } for (int ki = 0; ki < _num_blocks; ki++) { const int n_row = ((ki == (_num_blocks - 1)) ? _block_size_last : _block_size); const int dst_row = n_row; for (int kj = ki; kj < _num_blocks; kj++) { const int n_col = ((kj == (_num_blocks - 1)) ? _block_size_last : _block_size); T *a_upper = addrCoefBlock(ki, kj); int j, j0, j1; for (j1 = (ki + kj * _dim) * _block_size, j0 = 0, j = 0; j < n_col; j++, j1 += _dim, j0 += dst_row) { blas_copy(n_row, (T *)a + j1, 1, a_upper + j0, 1); } } // loop : kj } // loop : ki if (!_isSym) { for (int ki = 0; ki < _num_blocks; ki++) { const int n_row = (ki == (_num_blocks - 1)) ? _block_size_last : _block_size; for (int kj = 0; kj < ki; kj++) { const int n_col = _block_size; T *a_lower = addrCoefBlock(ki, kj); int dst_row = nrowBlock(ki, kj); int j, j0, j1; for (j1 = (ki + kj * _dim) * _block_size, j0 = 0, j = 0; j < n_col; j++, j1 += _dim, j0++) { blas_copy(n_row, (T *)a + j1, 1, a_lower + j0, dst_row); } } // loop : kj } // loop : ki } // if (!isSym) } template void SquareBlockMatrix::copyFromArray(const double *a, int dim); template void SquareBlockMatrix::copyFromArray(const quadruple *a, int dim); template void SquareBlockMatrix >:: copyFromArray(const complex *a, int dim); template void SquareBlockMatrix >:: copyFromArray(const complex *a, int dim); template void SquareBlockMatrix::copyFromArray(const float *a, int dim); template void SquareBlockMatrix >:: copyFromArray(const complex *a, int dim); // template void SquareBlockMatrix::copyFromArrayPermute(const T *a, int dim, int *permute) { if (_isdecomposed) { fprintf(stderr, "%s %d : copyFromArray() cannot copy decompesd data\n", __FILE__, __LINE__); return; } if (dim != _dim) { fprintf(stderr, "%s %d : mismatched dim %d != %d\n", __FILE__, __LINE__, dim, _dim); return; } for (int ki = 0; ki < _num_blocks; ki++) { const int n_row = ((ki == (_num_blocks - 1)) ? _block_size_last : _block_size); const int dst_row = n_row; for (int kj = ki; kj < _num_blocks; kj++) { const int n_col = ((kj == (_num_blocks - 1)) ? _block_size_last : _block_size); T *a_upper = addrCoefBlock(ki, kj); int j, j0, j1; for (j1 = (ki + kj * _dim) * _block_size, j0 = 0, j = 0; j < n_col; j++, j1 += _dim, j0 += dst_row) { const int jj = permute[kj * _block_size + j]; int ii = ki * _block_size; int kk = j0; if (!_isSym) { for (int i = 0; i < n_row; i++, kk++, ii++) { a_upper[kk] = a[permute[ii] + jj * _dim]; } } else { for (int i = 0; i < n_row; i++, kk++, ii++) { const int itmp = permute[ii]; a_upper[kk] = a[itmp <= jj ? itmp + jj * _dim : jj + itmp * _dim]; } } // if (!isSym) { // blas_copy(n_row, (T *)a + j1, 1, a_upper + j0, 1); } } // loop : kj } // loop : ki if (!_isSym) { for (int ki = 0; ki < _num_blocks; ki++) { const int n_row = ((ki == (_num_blocks - 1)) ? _block_size_last : _block_size); for (int kj = 0; kj < ki; kj++) { const int n_col = _block_size; T *a_lower = addrCoefBlock(ki, kj); const int dst_row = nrowBlock(ki, kj); int j, j0, j1; for (j1 = (ki + kj * _dim) * _block_size, j0 = 0, j = 0; j < n_col; j++, j1 += _dim, j0++) { const int jj = permute[kj * _block_size + j]; int ii = ki * _block_size; int kk = j0; for (int i = 0; i < n_row; i++, ii++, kk += dst_row) { a_lower[kk] = a[permute[ii] + jj * _dim]; } // blas_copy(n_row, (T *)a + j1, 1, a_lower + j0, dst_row); } } // loop : kj } // loop : ki } // if (!isSym) } template void SquareBlockMatrix::copyFromArrayPermute(const double *a, int dim, int *permute); template void SquareBlockMatrix::copyFromArrayPermute(const quadruple *a, int dim, int *permute); template void SquareBlockMatrix >:: copyFromArrayPermute(const complex *a, int dim, int *permute); template void SquareBlockMatrix >:: copyFromArrayPermute(const complex *a, int dim, int *permute); template void SquareBlockMatrix::copyFromArrayPermute(const float *a, int dim, int *permute); template void SquareBlockMatrix >:: copyFromArrayPermute(const complex *a, int dim, int *permute); // template void SquareBlockMatrix::copyToArrayFull(const T *a, int dim) { if (dim != _dim) { fprintf(stderr, "%s %d : mismatched dim %d != %d\n", __FILE__, __LINE__, dim, _dim); return; } // copy upper part for (int ki = 0; ki < _num_blocks; ki++) { const int n_row = ((ki == (_num_blocks - 1)) ? _block_size_last : _block_size); const int dst_row = n_row; for (int kj = ki; kj < _num_blocks; kj++) { const int n_col = ((kj == (_num_blocks - 1)) ? _block_size_last : _block_size); T *a_upper = addrCoefBlock(ki, kj); int j, j0, j1; for (j1 = (ki + kj * _dim) * _block_size, j0 = 0, j = 0; j < n_col; j++, j1 += _dim, j0 += dst_row) { blas_copy(n_row, a_upper + j0, 1, (T *)a + j1, 1); } } // loop : kj } // loop : ki // copy lower part if (_isSym) { for (int ki = 0; ki < _num_blocks; ki++) { const int n_row = ((ki == (_num_blocks - 1)) ? _block_size_last : _block_size); for (int kj = 0; kj < ki; kj++) { const int n_col = _block_size; const int dst_col = n_col; T *a_upper = addrCoefBlock(kj, ki); // transposed access int j, j0, j1; for (j1 = (ki + kj * _dim) * _block_size, j0 = 0, j = 0; j < n_row; j++, j1++, j0 += dst_col) { blas_copy(n_col, a_upper + j0, 1, (T *)a + j1, _dim); } } // loop : kj } // loop : ki } else { for (int ki = 0; ki < _num_blocks; ki++) { const int n_row = ((ki == (_num_blocks - 1)) ? _block_size_last : _block_size); for (int kj = 0; kj < ki; kj++) { const int n_col = _block_size; T *a_upper = addrCoefBlock(ki, kj); const int src_row = nrowBlock(ki, kj); int j, j0, j1; for (j1 = (ki + kj * _dim) * _block_size, j0 = 0, j = 0; j < n_col; j++, j1 += _dim, j0++) { blas_copy(n_row, a_upper + j0, src_row, (T *)a + j1, 1); } } // loop : kj } // loop : ki } } template void SquareBlockMatrix::copyToArrayFull(const double *a, int dim); template void SquareBlockMatrix::copyToArrayFull(const quadruple *a, int dim); template void SquareBlockMatrix >:: copyToArrayFull(const complex *a, int dim); template void SquareBlockMatrix >:: copyToArrayFull(const complex *a, int dim); template void SquareBlockMatrix::copyToArrayFull(const float *a, int dim); template void SquareBlockMatrix >:: copyToArrayFull(const complex *a, int dim); // template void SquareBlockMatrix::copyBlockToArray(int i, int j, const T *a, int dim) { if (dim != _dim) { fprintf(stderr, "%s %d : mismatched dim %d != %d\n", __FILE__, __LINE__, dim, _dim); return; } if (_isSym && i > j) { fprintf(stderr, "%s %d : symmetric matrix has upper block only : %d > %d\n", __FILE__, __LINE__, i, j); return; } T *a_src = addrCoefBlock(i, j); int j0, j1, j2; if (i <= j) { const int n_row = ((i == (_num_blocks - 1)) ? _block_size_last : _block_size); const int dst_row = n_row; const int n_col = ((j == (_num_blocks - 1)) ? _block_size_last : _block_size); for (j2 = (i + j * _dim) * _block_size, j1 = 0, j0 = 0; j0 < n_col; j0++, j1 += dst_row, j2 += _dim) { blas_copy(n_row, a_src + j1, 1, (T *)a + j2, 1); } } else { const int n_row = ((i == (_num_blocks - 1)) ? _block_size_last : _block_size); const int n_col = ((j == (_num_blocks - 1)) ? _block_size_last : _block_size); const int dst_col = n_col; for (j2 = (i + j * _dim) * _block_size, j1 = 0, j0 = 0; j0 < n_col; j0++, j1++, j2 += _dim) { blas_copy(n_row, a_src + j1, dst_col, (T *)a + j2, 1); } } } template void SquareBlockMatrix::copyBlockToArray(int i, int j, const double *a, int dim); template void SquareBlockMatrix::copyBlockToArray(int i, int j, const quadruple *a, int dim); template void SquareBlockMatrix >:: copyBlockToArray(int i, int j, const complex *a, int dim); template void SquareBlockMatrix >:: copyBlockToArray(int i, int j, const complex *a, int dim); template void SquareBlockMatrix::copyBlockToArray(int i, int j, const float *a, int dim); template void SquareBlockMatrix >:: copyBlockToArray(int i, int j, const complex *a, int dim);