/*! \file C_Dsub.cpp
\brief routines for substiution of off-diagonal matrix with strip
\author Atsushi Suzuki, Laboratoire Jacques-Louis Lions
\date Jun. 20th 2014
\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 "Compiler/OptionLibrary.hpp"
#include
#include "Compiler/blas.hpp"
#include "Driver/C_threads_tasks.hpp"
#include "Driver/C_Dsub.hpp"
#include "Compiler/DissectionIO.hpp"
template
void C_Dsub_task_exec(void *arg_)
{
list* >*arg = (list* >*)arg_;
int k = 0;
for (typename list* >::const_iterator it = arg->begin();
it != arg->end(); ++it, k++) {
(*it)->func(*it);
}
}
template
void C_Dsub_task_exec(void *arg_);
template
void C_Dsub_task_exec(void *arg_);
template
void C_Dsub_task_exec >(void *arg_);
template
void C_Dsub_task_exec >(void *arg_);
template
void C_Dsub_task_exec(void *arg_);
template
void C_Dsub_task_exec >(void *arg_);
// #define DEBUG_BLOCKSUBT
template
void dsub_sym2sym_diag(C_Dsub_task *arg)
{
const int ir_bgn = arg->ir_bgn;
const int ir_end = arg->ir_end;
const int ir_bgn_src = arg->ir_bgn_src;
T *dst_pt = arg->dst_mtrx->addrCoefBlock(arg->ir_block, arg->jc_block);
const int dst_row = arg->dst_mtrx->nrowBlock(arg->ir_block, arg->jc_block);
SquareBlockMatrix *src_mtrx = arg->src_pt;
const int nrow = ir_end - ir_bgn;
const int iblock0 = src_mtrx->BlockIndex(ir_bgn_src);
const int iblock1 = src_mtrx->BlockIndex(ir_bgn_src + nrow - 1);
const int nrow_src_offset = src_mtrx->BlockOffset(ir_bgn_src);
const T none(-1.0);
if ((iblock0 + 1) == iblock1) {
const int ir_mid_src = src_mtrx->IndexBlock(iblock1); // iblock1 * SIZE_B1;
const int nrow0 = ir_mid_src - ir_bgn_src;
const int nrow1 = nrow - nrow0;
const int ir_mid = ir_bgn + nrow0;
{
int jj, j0, j1;
const int nrow_src = src_mtrx->nrowBlock(iblock0, iblock0);
T *src_pt = src_mtrx->addrCoefBlock(iblock0, iblock0);
for (j1 = nrow_src_offset * (nrow_src + 1),
j0 = ir_bgn * (dst_row + 1), //D(ir_bgn,ir_bgn)-(ir_mid,ir_mid)
jj = ir_bgn; jj < ir_mid; jj++, // driving index
j0 += dst_row, j1 += nrow_src) {
blas_axpy(nrow0, none, src_pt + j1, 1, dst_pt + j0, 1);
}
}
{
int jj, j0, j1, j2, j3, j4;
const int nrow_src1 = src_mtrx->nrowBlock(iblock1, iblock1);
const int nrow_src0 = src_mtrx->nrowBlock(iblock0, iblock1);
T *src_pt1 = src_mtrx->addrCoefBlock(iblock1, iblock1);
T *src_pt0 = src_mtrx->addrCoefBlock(iblock0, iblock1);
for (j4 = 0, j3 = nrow_src_offset,
j0 = ir_bgn + ir_mid * dst_row, // (ir_bgn,ir_mid)-(ir_mid,ir_end)
j1 = ir_mid * (dst_row + 1), //D(ir_mid,ir_mid)-(ir_end,ir_end)
j2 = ir_mid + ir_bgn * dst_row, //T(ir_bgn,ir_mid)-(ir_mid,ir_end)
jj = ir_mid; jj < ir_end; jj++, // driving index
j0 += dst_row, j1 += dst_row, j2++,
j3 += nrow_src0, j4 += nrow_src1) {
blas_axpy(nrow0, none, src_pt0 + j3, 1, dst_pt + j0, 1);
blas_axpy(nrow1, none, src_pt1 + j4, 1, dst_pt + j1, 1);
// lower part of Schur complement matrix
// blas_axpy(nrow0, none, src_pt0 + j3, 1, dst_pt + j2, dst_row);
}
}
}
else if (iblock0 == iblock1) {
int jj, j0, j1;
const int nrow_src = src_mtrx->nrowBlock(iblock0, iblock0);
T *src_pt = src_mtrx->addrCoefBlock(iblock0, iblock0);
for (j1 = nrow_src_offset * (nrow_src + 1),
j0 = ir_bgn * (dst_row + 1), //D(ir_bgn,ir_bgn)-(ir_end,ir_end)
jj = ir_bgn; jj < ir_end; jj++, // driving index
j0 += dst_row, j1 += nrow_src) {
blas_axpy(nrow, none, src_pt + j1, 1, dst_pt + j0, 1);
} // loop : j0, j1
}
else {
diss_printf(arg->verbose, arg->fp,
"%s %d : bad block indices in diagonal %d %d\n",
__FILE__, __LINE__, iblock0, iblock1);
}
}
template
void dsub_sym2sym_diag(C_Dsub_task *arg);
template
void dsub_sym2sym_diag(C_Dsub_task *arg);
template
void dsub_sym2sym_diag >(C_Dsub_task > *arg);
template
void dsub_sym2sym_diag >(C_Dsub_task > *arg);
template
void dsub_sym2sym_diag(C_Dsub_task *arg);
template
void dsub_sym2sym_diag >(C_Dsub_task > *arg);
// end of template function dsub_sym2sym_diag
template
void dsub_unsym2unsym_diag(C_Dsub_task *arg)
{
const int ir_bgn = arg->ir_bgn;
const int ir_end = arg->ir_end;
const int ir_bgn_src = arg->ir_bgn_src;
T *dst_pt = arg->dst_mtrx->addrCoefBlock(arg->ir_block, arg->jc_block);
const int dst_row = arg->dst_mtrx->nrowBlock(arg->ir_block, arg->jc_block);
SquareBlockMatrix *src_mtrx = arg->src_pt;
const int nrow = ir_end - ir_bgn;
const int iblock0 = src_mtrx->BlockIndex(ir_bgn_src);
const int iblock1 = src_mtrx->BlockIndex(ir_bgn_src + nrow - 1);
const int nrow_src_offset = src_mtrx->BlockOffset(ir_bgn_src);
// block copy : lower triangle to lower is enough
const T none(-1.0);
if ((iblock0 + 1) == iblock1) {
const int ir_mid_src = src_mtrx->IndexBlock(iblock1);
const int nrow0 = ir_mid_src - ir_bgn_src;
const int nrow1 = nrow - nrow0;
const int ir_mid = ir_bgn + nrow0;
{
int jj, j0, j1;
const int nrow_src = src_mtrx->nrowBlock(iblock0, iblock0);
T *src_pt = src_mtrx->addrCoefBlock(iblock0, iblock0);
for (j1 = nrow_src_offset * (nrow_src + 1),
j0 = ir_bgn * (dst_row + 1), //D(ir_bgn,ir_bgn)-(ir_mid,ir_mid)
jj = ir_bgn; jj < ir_mid; jj++, // driving index
j0 += dst_row, j1 += nrow_src) {
blas_axpy(nrow0, none, src_pt + j1, 1, dst_pt + j0, 1);
}
}
{
int jj, j0, j1, j2, j3, j4;
const int nrow_src1 = src_mtrx->nrowBlock(iblock1, iblock1);
const int nrow_src0 = src_mtrx->nrowBlock(iblock0, iblock1);
T *src_pt1 = src_mtrx->addrCoefBlock(iblock1, iblock1);
T *src_pt0 = src_mtrx->addrCoefBlock(iblock0, iblock1);
// lower part of Schur complement matrix
T *src_pt2 = src_mtrx->addrCoefBlock(iblock1, iblock0);
for (j4 = 0, j3 = nrow_src_offset,
j0 = ir_bgn + ir_mid * dst_row, // (ir_bgn,ir_mid)-(ir_mid,ir_end)
j1 = ir_mid * (dst_row + 1), //D(ir_mid,ir_mid)-(ir_end,ir_end)
j2 = ir_mid + ir_bgn * dst_row, //T(ir_bgn,ir_mid)-(ir_mid,ir_end)
jj = ir_mid; jj < ir_end; jj++, // driving index
j0 += dst_row, j1 += dst_row, j2++,
j3 += nrow_src0, j4 += nrow_src1) {
blas_axpy(nrow0, none, src_pt0 + j3, 1, dst_pt + j0, 1);
blas_axpy(nrow1, none, src_pt1 + j4, 1, dst_pt + j1, 1);
// lower part of Schur complement matrix
blas_axpy(nrow0, none, src_pt2 + j3, 1, dst_pt + j2, dst_row);
}
}
}
else if (iblock0 == iblock1) {
int jj, j0, j1;
const int nrow_src = src_mtrx->nrowBlock(iblock0, iblock0);
T *src_pt = src_mtrx->addrCoefBlock(iblock0, iblock0);
for (j1 = nrow_src_offset * (nrow_src + 1),
j0 = ir_bgn * (dst_row + 1), //D(ir_bgn,ir_bgn)-(ir_end,ir_end)
jj = ir_bgn; jj < ir_end; jj++, // driving index
j0 += dst_row, j1 += nrow_src) {
blas_axpy(nrow, none, src_pt + j1, 1, dst_pt + j0, 1);
} // loop : j0, j1
}
else {
diss_printf(arg->verbose, arg->fp,
"%s %d : bad block indices in diagonal %d %d\n",
__FILE__, __LINE__, iblock0, iblock1);
}
}
template
void dsub_unsym2unsym_diag(C_Dsub_task *arg);
template
void dsub_unsym2unsym_diag(C_Dsub_task *arg);
template
void dsub_unsym2unsym_diag >(C_Dsub_task >*arg);
template
void dsub_unsym2unsym_diag >(C_Dsub_task >*arg);
template
void dsub_unsym2unsym_diag(C_Dsub_task *arg);
template
void dsub_unsym2unsym_diag >(C_Dsub_task >*arg);
// end of template function dsub_unsym2unsym_diag
template
void dsub_sym2sym(C_Dsub_task *arg)
{
const int ir_bgn = arg->ir_bgn;
const int ir_end = arg->ir_end;
const int jc_bgn = arg->jc_bgn;
const int jc_end = arg->jc_end;
const int ir_bgn_src = arg->ir_bgn_src;
const int jc_bgn_src = arg->jc_bgn_src;
T *dst_pt = arg->dst_mtrx->addrCoefBlock(arg->ir_block, arg->jc_block);
const int dst_row = arg->dst_mtrx->nrowBlock(arg->ir_block, arg->jc_block);
SquareBlockMatrix *src_mtrx = arg->src_pt;
const int nrow = ir_end - ir_bgn;
const int ncol = jc_end - jc_bgn;
const int iblock0 = src_mtrx->BlockIndex(ir_bgn_src);
const int iblock1 = src_mtrx->BlockIndex(ir_bgn_src + nrow - 1);
const int nrow_src_offset = src_mtrx->BlockOffset(ir_bgn_src);
const int jblock0 = src_mtrx->BlockIndex(jc_bgn_src);
const int jblock1 = src_mtrx->BlockIndex(jc_bgn_src + ncol - 1);
const int ncol_src_offset = src_mtrx->BlockOffset(jc_bgn_src);
const T none(-1.0);
if ((iblock0 + 1) == iblock1) {
// decomposition is defined by src block with SIZE_B1
const int ir_mid_src = src_mtrx->IndexBlock(iblock1); // * SIZE_B1;
const int nrow0 = ir_mid_src - ir_bgn_src;
const int nrow1 = nrow - nrow0;
const int ir_mid = ir_bgn + nrow0;
if ((jblock0 + 1) == jblock1) {
const int jc_mid_src = src_mtrx->IndexBlock(jblock1); // * SIZE_B1;
const int ncol0 = jc_mid_src - jc_bgn_src;
const int jc_mid = jc_bgn + ncol0;
{
int jj, j0, j1, j2, j3;
const int nrow_src0 = src_mtrx->nrowBlock(iblock0, jblock0);
const int nrow_src1 = src_mtrx->nrowBlock(iblock1, jblock0);
T *src_pt0 = src_mtrx->addrCoefBlock(iblock0, jblock0);
T *src_pt1 = src_mtrx->addrCoefBlock(iblock1, jblock0);
// distnation : transpose of
// distnation : transpose of
for (j3 = ncol_src_offset * nrow_src1,
j2 = nrow_src_offset + ncol_src_offset * nrow_src0,
j0 = ir_bgn + jc_bgn * dst_row, // (ir_bgn,jc_bgn)-(ir_mid,jc_mid)
j1 = ir_mid + jc_bgn * dst_row, // (ir_mid,jc_bgn)-(ir_end,jc_mid)
jj = jc_bgn; jj < jc_mid; jj++, // drinving index
j0 += dst_row, j1 += dst_row, j2 += nrow_src0, j3 += nrow_src1) {
blas_axpy(nrow0, none, src_pt0 + j2, 1, dst_pt + j0, 1);
blas_axpy(nrow1, none, src_pt1 + j3, 1, dst_pt + j1, 1);
}
}
{
int jj, j0, j1, j2, j3;
const int nrow_src0 = src_mtrx->nrowBlock(iblock0, jblock1);
const int nrow_src1 = src_mtrx->nrowBlock(iblock1, jblock1);
T *src_pt0 = src_mtrx->addrCoefBlock(iblock0, jblock1);
T *src_pt1 = src_mtrx->addrCoefBlock(iblock1, jblock1);
// distnation : transpose of
// distnation : transpose of
for (j3 = 0, j2 = nrow_src_offset,
j0 = ir_bgn + jc_mid * dst_row, // (ir_bgn,jc_mid)-(ir_mid,jc_end)
j1 = ir_mid + jc_mid * dst_row, // (ir_mid,jc_mid)-(ir_end,jc_end)
jj = jc_mid; jj < jc_end; jj++, // driving index
j0 += dst_row, j1 += dst_row, j2 += nrow_src0, j3 += nrow_src1) {
blas_axpy(nrow0, none, src_pt0 + j2, 1, dst_pt + j0, 1);
blas_axpy(nrow1, none, src_pt1 + j3, 1, dst_pt + j1, 1);
}
}
} // if ((jblock0 + 1) == jblock1) {
else if (jblock0 == jblock1) {
int jj, j0, j1, j2, j3;
const int nrow_src0 = src_mtrx->nrowBlock(iblock0, jblock0);
const int nrow_src1 = src_mtrx->nrowBlock(iblock1, jblock0);
T *src_pt0 = src_mtrx->addrCoefBlock(iblock0, jblock0);
T *src_pt1 = src_mtrx->addrCoefBlock(iblock1, jblock0);
// distnation : transpose of
// distnation : transpose of
for (j3 = ncol_src_offset * nrow_src1,
j2 = nrow_src_offset + ncol_src_offset * nrow_src0,
j0 = ir_bgn + jc_bgn * dst_row, // (ir_bgn,jc_bgn)-(ir_mid,jc_end)
j1 = ir_mid + jc_bgn * dst_row, // (ir_mid,jc_bgn)-(ir_end,jc_end)
jj = jc_bgn; jj < jc_end; jj++, // driving index
j0 += dst_row, j1 += dst_row, j2 += nrow_src0, j3 += nrow_src1) {
blas_axpy(nrow0, none, src_pt0 + j2, 1, dst_pt + j0, 1);
blas_axpy(nrow1, none, src_pt1 + j3, 1, dst_pt + j1, 1);
}
}
else {
diss_printf(arg->verbose, arg->fp,
"%s %d : bad block indices in column : %d %d\n",
__FILE__, __LINE__, jblock0, jblock1);
}
}
else if (iblock0 == iblock1) {
if ((jblock0 + 1) == jblock1) {
const int jc_mid_src = src_mtrx->IndexBlock(jblock1);// * SIZE_B1;
const int ncol0 = jc_mid_src - jc_bgn_src;
const int jc_mid = jc_bgn + ncol0;
{
int jj, j0, j1;
const int nrow_src = src_mtrx->nrowBlock(iblock0, jblock0);
T *src_pt = src_mtrx->addrCoefBlock(iblock0, jblock0);
for (j1 = nrow_src_offset + ncol_src_offset * nrow_src,
j0 = ir_bgn + jc_bgn * dst_row, // (ir_bgn,jc_bgn)-(ir_end,jc_mid)
jj = jc_bgn; jj < jc_mid; jj++, // driving index
j0 += dst_row, j1 += nrow_src) {
blas_axpy(nrow, none, src_pt + j1, 1, dst_pt + j0, 1);
}
}
{
int jj, j0, j1;
const int nrow_src = src_mtrx->nrowBlock(iblock0, jblock1);
T *src_pt = src_mtrx->addrCoefBlock(iblock0, jblock1);
// distnation : transpose of
for (j1 = nrow_src_offset,
j0 = ir_bgn + jc_mid * dst_row, // (ir_bgn,jc_mid)-(ir_end,jc_end)
jj = jc_mid; jj < jc_end; jj++, // driving index
j0 += dst_row, j1 += nrow_src) {
blas_axpy(nrow, none, src_pt + j1, 1, dst_pt + j0, 1);
}
}
}
else {
int jj, j0, j1;
const int nrow_src = src_mtrx->nrowBlock(iblock0, jblock0);
T *src_pt = src_mtrx->addrCoefBlock(iblock0, jblock0);
// distnation : transpose of
for (j1 = nrow_src_offset + ncol_src_offset * nrow_src,
j0 = ir_bgn + jc_bgn * dst_row, // (ir_bgn,jc_bgn)-(ir_end,jc_end)
jj = jc_bgn; jj < jc_end; jj++, // driving index
j0 += dst_row, j1 += nrow_src) {
blas_axpy(nrow, none, src_pt + j1, 1, dst_pt + j0, 1);
}
}
} // if ((jblock0 + 1) == jblock1)
else {
diss_printf(arg->verbose, arg->fp,
"%s %d : bad block indices in row : %d %d\n",
__FILE__, __LINE__, iblock0, iblock1);
}
}
template
void dsub_sym2sym(C_Dsub_task *arg);
template
void dsub_sym2sym(C_Dsub_task *arg);
template
void dsub_sym2sym >(C_Dsub_task > *arg);
template
void dsub_sym2sym >(C_Dsub_task > *arg);
template
void dsub_sym2sym(C_Dsub_task *arg);
template
void dsub_sym2sym >(C_Dsub_task > *arg);
// end of template function dsub_sym2sym
template
void dsub_unsym2unsym(C_Dsub_task *arg)
{
const int ir_bgn = arg->ir_bgn;
const int ir_end = arg->ir_end;
const int jc_bgn = arg->jc_bgn;
const int jc_end = arg->jc_end;
const int ir_bgn_src = arg->ir_bgn_src;
const int jc_bgn_src = arg->jc_bgn_src;
T *dst_pt = arg->dst_mtrx->addrCoefBlock(arg->ir_block, arg->jc_block);
const int dst_row = arg->dst_mtrx->nrowBlock(arg->ir_block, arg->jc_block);
T *dst_pt2 = arg->dst_mtrx->addrCoefBlock(arg->jc_block, arg->ir_block);
SquareBlockMatrix *src_mtrx = arg->src_pt;
const int nrow = ir_end - ir_bgn;
const int ncol = jc_end - jc_bgn;
const int iblock0 = src_mtrx->BlockIndex(ir_bgn_src);
const int iblock1 = src_mtrx->BlockIndex(ir_bgn_src + nrow - 1);
const int nrow_src_offset = src_mtrx->BlockOffset(ir_bgn_src);
const int jblock0 = src_mtrx->BlockIndex(jc_bgn_src);
const int jblock1 = src_mtrx->BlockIndex(jc_bgn_src + ncol - 1);
const int ncol_src_offset = src_mtrx->BlockOffset(jc_bgn_src);
const T none(-1.0);
if ((iblock0 + 1) == iblock1) {
// decomposition is defined by src block with SIZE_B1
const int ir_mid_src = src_mtrx->IndexBlock(iblock1);// * SIZE_B1;
const int nrow0 = ir_mid_src - ir_bgn_src;
const int nrow1 = nrow - nrow0;
const int ir_mid = ir_bgn + nrow0;
if ((jblock0 + 1) == jblock1) {
const int jc_mid_src = src_mtrx->IndexBlock(jblock1);// * SIZE_B1;
const int ncol0 = jc_mid_src - jc_bgn_src;
const int jc_mid = jc_bgn + ncol0;
{
int jj, j0, j1, j2, j3;
const int nrow_src0 = src_mtrx->nrowBlock(iblock0, jblock0);
const int nrow_src1 = src_mtrx->nrowBlock(iblock1, jblock0);
T *src_pt0 = src_mtrx->addrCoefBlock(iblock0, jblock0);
T *src_pt1 = src_mtrx->addrCoefBlock(iblock1, jblock0);
for (j3 = ncol_src_offset * nrow_src1,
j2 = nrow_src_offset + ncol_src_offset * nrow_src0,
j0 = ir_bgn + jc_bgn * dst_row, //(ir_bgn,jc_bgn)-(ir_mid,jc_mid)
j1 = ir_mid + jc_bgn * dst_row, //(ir_mid,jc_bgn)-(ir_end,jc_mid)
jj = jc_bgn; jj < jc_mid; jj++, // drinving index
j0 += dst_row, j1 += dst_row,
j2 += nrow_src0, j3 += nrow_src1) {
blas_axpy(nrow0, none, src_pt0 + j2, 1, dst_pt + j0, 1);
blas_axpy(nrow1, none, src_pt1 + j3, 1, dst_pt + j1, 1);
}
}
// lower part of Schur complement matrix
{
int jj, j0, j2;
const int nrow_src0 = src_mtrx->nrowBlock(iblock0, jblock0);
T *src_pt2 = src_mtrx->addrCoefBlock(jblock0, iblock0);
{
for (j2 = nrow_src_offset + ncol_src_offset * nrow_src0,
j0 = ir_bgn + jc_bgn * dst_row, //(ir_bgn,jc_bgn)-(ir_mid,jc_mid)
jj = jc_bgn; jj < jc_mid; jj++, // drinving index
j0 += dst_row,
j2 += nrow_src0) {
blas_axpy(nrow0, none, src_pt2 + j2, 1, dst_pt2 + j0, 1);
}
}
}
{
int jj, j1, j3;
const int nrow_src1 = src_mtrx->nrowBlock(iblock1, jblock0);
T *src_pt3 = src_mtrx->addrCoefBlock(jblock0, iblock1);
if (iblock1 == jblock0) {
for (j3 = ncol_src_offset,
j1 = ir_mid + jc_bgn * dst_row, //(ir_mid,jc_bgn)-(ir_end,jc_mid)
jj = jc_bgn; jj < jc_mid; jj++, // drinving index
j1 += dst_row,
j3++) {
blas_axpy(nrow1, none, src_pt3 + j3, nrow_src1, dst_pt2 + j1, 1);
}
}
else {
for (j3 = ncol_src_offset * nrow_src1,
j1 = ir_mid + jc_bgn * dst_row, //(ir_mid,jc_bgn)-(ir_end,jc_mid)
jj = jc_bgn; jj < jc_mid; jj++, // drinving index
j1 += dst_row,
j3 += nrow_src1) {
blas_axpy(nrow1, none, src_pt3 + j3, 1, dst_pt2 + j1, 1);
}
}
}
{
int jj, j0, j1, j2, j3;
const int nrow_src0 = src_mtrx->nrowBlock(iblock0, jblock1);
const int nrow_src1 = src_mtrx->nrowBlock(iblock1, jblock1);
T *src_pt0 = src_mtrx->addrCoefBlock(iblock0, jblock1);
T *src_pt1 = src_mtrx->addrCoefBlock(iblock1, jblock1);
for (j3 = 0, j2 = nrow_src_offset,
j0 = ir_bgn + jc_mid * dst_row, //(ir_bgn,jc_mid)-(ir_mid,jc_end)
j1 = ir_mid + jc_mid * dst_row, //(ir_mid,jc_mid)-(ir_end,jc_end)
jj = jc_mid; jj < jc_end; jj++, //driving index
j0 += dst_row, j1 += dst_row,
j2 += nrow_src0, j3 += nrow_src1) {
blas_axpy(nrow0, none, src_pt0 + j2, 1, dst_pt + j0, 1);
blas_axpy(nrow1, none, src_pt1 + j3, 1, dst_pt + j1, 1);
}
}
{
int jj, j0, j2;
const int nrow_src0 = src_mtrx->nrowBlock(iblock0, jblock1);
T *src_pt2 = src_mtrx->addrCoefBlock(jblock1, iblock0);
{
for (j2 = nrow_src_offset,
j0 = ir_bgn + jc_mid * dst_row, //(ir_bgn,jc_mid)-(ir_mid,jc_end)
jj = jc_mid; jj < jc_end; jj++, //driving index
j0 += dst_row,
j2 += nrow_src0) {
blas_axpy(nrow0, none, src_pt2 + j2, 1, dst_pt2 + j0, 1);
}
}
}
{
int jj, j1, j3;
const int nrow_src1 = src_mtrx->nrowBlock(iblock1, jblock1);
T *src_pt3 = src_mtrx->addrCoefBlock(jblock1, iblock1);
{
for (j3 = 0,
j1 = ir_mid + jc_mid * dst_row, //(ir_mid,jc_mid)-(ir_end,jc_end)
jj = jc_mid; jj < jc_end; jj++, //driving index
j1 += dst_row,
j3 += nrow_src1) {
blas_axpy(nrow1, none, src_pt3 + j3, 1, dst_pt2 + j1, 1);
}
}
}
} // if ((jblock0 + 1) == jblock1) {
else if (jblock0 == jblock1) {
{
int jj, j0, j1, j2, j3;
const int nrow_src0 = src_mtrx->nrowBlock(iblock0, jblock0);
const int nrow_src1 = src_mtrx->nrowBlock(iblock1, jblock0);
T *src_pt0 = src_mtrx->addrCoefBlock(iblock0, jblock0);
T *src_pt1 = src_mtrx->addrCoefBlock(iblock1, jblock0);
for (j3 = ncol_src_offset * nrow_src1,
j2 = nrow_src_offset + ncol_src_offset * nrow_src0,
j0 = ir_bgn + jc_bgn * dst_row, // (ir_bgn,jc_bgn)-(ir_mid,jc_end)
j1 = ir_mid + jc_bgn * dst_row, // (ir_mid,jc_bgn)-(ir_end,jc_end)
jj = jc_bgn; jj < jc_end; jj++, // driving index
j0 += dst_row, j1 += dst_row,
j2 += nrow_src0, j3 += nrow_src1) {
blas_axpy(nrow0, none, src_pt0 + j2, 1, dst_pt + j0, 1);
blas_axpy(nrow1, none, src_pt1 + j3, 1, dst_pt + j1, 1);
}
}
{
int jj, j0, j2;
const int nrow_src0 = src_mtrx->nrowBlock(iblock0, jblock0);
T *src_pt2 = src_mtrx->addrCoefBlock(jblock0, iblock0);
{
for (j2 = nrow_src_offset + ncol_src_offset * nrow_src0,
j0 = ir_bgn + jc_bgn * dst_row, //(ir_bgn,jc_bgn)-(ir_mid,jc_end)
jj = jc_bgn; jj < jc_end; jj++, // driving index
j0 += dst_row,
j2 += nrow_src0) {
blas_axpy(nrow0, none, src_pt2 + j2, 1, dst_pt2 + j0, 1);
}
}
}
{
int jj, j1, j3;
const int nrow_src1 = src_mtrx->nrowBlock(iblock1, jblock0);
T *src_pt3 = src_mtrx->addrCoefBlock(jblock0, iblock1);
if (iblock1 == jblock0) {
for (j3 = ncol_src_offset, // transposed
j1 = ir_mid + jc_bgn * dst_row, //(ir_mid,jc_bgn)-(ir_end,jc_end)
jj = jc_bgn; jj < jc_end; jj++, // driving index
j1 += dst_row,
j3++) {
blas_axpy(nrow1, none, src_pt3 + j3, nrow_src1, dst_pt2 + j1, 1);
}
}
else {
for (j3 = ncol_src_offset * nrow_src1,
j1 = ir_mid + jc_bgn * dst_row, //(ir_mid,jc_bgn)-(ir_end,jc_end)
jj = jc_bgn; jj < jc_end; jj++, // driving index
j1 += dst_row,
j3 += nrow_src1) {
blas_axpy(nrow1, none, src_pt3 + j3, 1, dst_pt2 + j1, 1);
}
}
}
}
else {
diss_printf(arg->verbose, arg->fp,
"%s %d : bad block indices in column : %d %d\n",
__FILE__, __LINE__, jblock0, jblock1);
}
}
else if (iblock0 == iblock1) {
if ((jblock0 + 1) == jblock1) {
const int jc_mid_src = src_mtrx->IndexBlock(jblock1);// * SIZE_B1;
const int ncol0 = jc_mid_src - jc_bgn_src;
const int jc_mid = jc_bgn + ncol0;
{
int jj, j0, j1;
const int nrow_src = src_mtrx->nrowBlock(iblock0, jblock0);
T *src_pt = src_mtrx->addrCoefBlock(iblock0, jblock0);
for (j1 = nrow_src_offset + ncol_src_offset * nrow_src,
j0 = ir_bgn + jc_bgn * dst_row, //(ir_bgn,jc_bgn)-(ir_end,jc_mid)
jj = jc_bgn; jj < jc_mid; jj++, // driving index
j0 += dst_row, j1 += nrow_src) {
blas_axpy(nrow, none, src_pt + j1, 1, dst_pt + j0, 1);
}
}
{
int jj, j0, j1;
const int nrow_src = src_mtrx->nrowBlock(iblock0, jblock0);
T *src_pt2 = src_mtrx->addrCoefBlock(jblock0, iblock0);
if (iblock0 == jblock0) {
for (j1 = ncol_src_offset + nrow_src_offset * nrow_src, // transposed
j0 = ir_bgn + jc_bgn * dst_row, //(ir_bgn,jc_bgn)-(ir_end,jc_mid)
jj = jc_bgn; jj < jc_mid; jj++, // driving index
j0 += dst_row, j1++) {
blas_axpy(nrow, none, src_pt2 + j1, nrow_src, dst_pt2 + j0, 1);
}
}
else {
for (j1 = nrow_src_offset + ncol_src_offset * nrow_src,
j0 = ir_bgn + jc_bgn * dst_row, //(ir_bgn,jc_bgn)-(ir_end,jc_mid)
jj = jc_bgn; jj < jc_mid; jj++, // driving index
j0 += dst_row, j1 += nrow_src) {
blas_axpy(nrow, none, src_pt2 + j1, 1, dst_pt2 + j0, 1);
}
}
}
{
int jj, j0, j1;
const int nrow_src = src_mtrx->nrowBlock(iblock0, jblock1);
T *src_pt = src_mtrx->addrCoefBlock(iblock0, jblock1);
for (j1 = nrow_src_offset,
j0 = ir_bgn + jc_mid * dst_row, // (ir_bgn,jc_mid)-(ir_end,jc_end)
jj = jc_mid; jj < jc_end; jj++, // driving index
j0 += dst_row, j1 += nrow_src) {
blas_axpy(nrow, none, src_pt + j1, 1, dst_pt + j0, 1);
}
}
{
int jj, j0, j1;
const int nrow_src = src_mtrx->nrowBlock(iblock0, jblock1);
T *src_pt2 = src_mtrx->addrCoefBlock(jblock1, iblock0);
{
for (j1 = nrow_src_offset,
j0 = ir_bgn + jc_mid * dst_row, //(ir_bgn,jc_mid)-(ir_end,jc_end)
jj = jc_mid; jj < jc_end; jj++, // driving index
j0 += dst_row, j1 += nrow_src) {
blas_axpy(nrow, none, src_pt2 + j1, 1, dst_pt2 + j0, 1);
}
}
}
}
else {
{
int jj, j0, j1;
const int nrow_src = src_mtrx->nrowBlock(iblock0, jblock0);
T *src_pt = src_mtrx->addrCoefBlock(iblock0, jblock0);
for (j1 = nrow_src_offset + ncol_src_offset * nrow_src,
j0 = ir_bgn + jc_bgn * dst_row, // (ir_bgn,jc_bgn)-(ir_end,jc_end)
jj = jc_bgn; jj < jc_end; jj++, // driving index
j0 += dst_row, j1 += nrow_src) {
blas_axpy(nrow, none, src_pt + j1, 1, dst_pt + j0, 1);
}
}
{
int jj, j0, j1;
const int nrow_src = src_mtrx->nrowBlock(iblock0, jblock0);
T *src_pt2 = src_mtrx->addrCoefBlock(jblock0, iblock0);
if (iblock0 == jblock0) {
for (j1 = ncol_src_offset + nrow_src_offset * nrow_src, // transposed
j0 = ir_bgn + jc_bgn * dst_row, //(ir_bgn,jc_bgn)-(ir_end,jc_end)
jj = jc_bgn; jj < jc_end; jj++, // driving index
j0 += dst_row, j1++) {
blas_axpy(nrow, none, src_pt2 + j1, nrow_src, dst_pt2 + j0, 1);
}
}
else {
for (j1 = nrow_src_offset + ncol_src_offset * nrow_src,
j0 = ir_bgn + jc_bgn * dst_row, //(ir_bgn,jc_bgn)-(ir_end,jc_end)
jj = jc_bgn; jj < jc_end; jj++, // driving index
j0 += dst_row, j1 += nrow_src) {
blas_axpy(nrow, none, src_pt2 + j1, 1, dst_pt2 + j0, 1);
}
}
}
}
} // if ((jblock0 + 1) == jblock1)
else {
diss_printf(arg->verbose, arg->fp,
"%s %d : bad block indices in row : %d %d\n",
__FILE__, __LINE__, iblock0, iblock1);
}
}
template
void dsub_unsym2unsym(C_Dsub_task *arg);
template
void dsub_unsym2unsym(C_Dsub_task *arg);
template
void dsub_unsym2unsym >(C_Dsub_task > *arg);
template
void dsub_unsym2unsym >(C_Dsub_task > *arg);
template
void dsub_unsym2unsym(C_Dsub_task *arg);
template
void dsub_unsym2unsym >(C_Dsub_task > *arg);
// end of template function dsub_unsym2unsym
template
void dsub_unsym2diag(C_Dsub_task *arg)
{
// destination is inside of a diagonal block : ir_block == jc_block
const int ir_bgn = arg->ir_bgn;
const int ir_end = arg->ir_end;
const int jc_bgn = arg->jc_bgn;
const int jc_end = arg->jc_end;
const int ir_bgn_src = arg->ir_bgn_src;
const int jc_bgn_src = arg->jc_bgn_src;
T *dst_pt = arg->dst_mtrx->addrCoefBlock(arg->ir_block, arg->jc_block);
const int dst_row = arg->dst_mtrx->nrowBlock(arg->ir_block, arg->jc_block);
SquareBlockMatrix *src_mtrx = arg->src_pt;
const int nrow = ir_end - ir_bgn;
const int ncol = jc_end - jc_bgn;
const int iblock0 = src_mtrx->BlockIndex(ir_bgn_src);
const int iblock1 = src_mtrx->BlockIndex(ir_bgn_src + nrow - 1);
const int nrow_src_offset = src_mtrx->BlockOffset(ir_bgn_src);
const int jblock0 = src_mtrx->BlockIndex(jc_bgn_src);
const int jblock1 = src_mtrx->BlockIndex(jc_bgn_src + ncol - 1);
const int ncol_src_offset = src_mtrx->BlockOffset(jc_bgn_src);
const T none(-1.0);
if ((iblock0 + 1) == iblock1) {
// decomposition is defined by src block with SIZE_B1
const int ir_mid_src = src_mtrx->IndexBlock(iblock1);
const int nrow0 = ir_mid_src - ir_bgn_src;
const int nrow1 = nrow - nrow0;
const int ir_mid = ir_bgn + nrow0;
if ((jblock0 + 1) == jblock1) {
const int jc_mid_src = src_mtrx->IndexBlock(jblock1);
const int ncol0 = jc_mid_src - jc_bgn_src;
const int jc_mid = jc_bgn + ncol0;
{
int jj, j0, j1, j2, j3, j4, j5;
const int nrow_src0 = src_mtrx->nrowBlock(iblock0, jblock0);
const int nrow_src1 = src_mtrx->nrowBlock(iblock1, jblock0);
T *src_pt0 = src_mtrx->addrCoefBlock(iblock0, jblock0);
T *src_pt1 = src_mtrx->addrCoefBlock(iblock1, jblock0);
// lower part of Schur complement matrix
for (j5 = ncol_src_offset * nrow_src1,
j4 = nrow_src_offset + ncol_src_offset * nrow_src0,
j0 = ir_bgn + jc_bgn * dst_row, // (ir_bgn,jc_bgn)-(ir_mid,jc_mid)
j1 = ir_mid + jc_bgn * dst_row, // (ir_mid,jc_bgn)-(ir_end,jc_mid)
jj = jc_bgn; jj < jc_mid; jj++, // drinving index
j0 += dst_row, j1 += dst_row,
j4 += nrow_src0, j5 += nrow_src1) {
blas_axpy(nrow0, none, src_pt0 + j4, 1, dst_pt + j0, 1);
blas_axpy(nrow1, none, src_pt1 + j5, 1, dst_pt + j1, 1);
}
// lower part of Schur complement matrix
T *src_pt2 = src_mtrx->addrCoefBlock(jblock0, iblock0);
T *src_pt3 = src_mtrx->addrCoefBlock(jblock0, iblock1);
if (iblock1 == jblock0) {
for (j5 = ncol_src_offset, // transposted
j4 = nrow_src_offset + ncol_src_offset * nrow_src0,
j2 = jc_bgn + ir_bgn * dst_row,//(ir_bgn,jc_bgn)-(ir_mid,jc_mid)
j3 = jc_bgn + ir_mid * dst_row,//(ir_mid,jc_bgn)-(ir_end,jc_mid)
jj = jc_bgn; jj < jc_mid; jj++, // drinving index
j2++, j3++,
j4 += nrow_src0, j5++) {
blas_axpy(nrow0, none, src_pt2 + j4, 1, // transposed
dst_pt + j2, dst_row);
blas_axpy(nrow1, none, src_pt3 + j5, nrow_src1, // both in the
dst_pt + j3, dst_row); // diagonal
}
}
else {
for (j5 = ncol_src_offset * nrow_src1,
j4 = nrow_src_offset + ncol_src_offset * nrow_src0,
j2 = jc_bgn + ir_bgn * dst_row,//(ir_bgn,jc_bgn)-(ir_mid,jc_mid)
j3 = jc_bgn + ir_mid * dst_row,//(ir_mid,jc_bgn)-(ir_end,jc_mid)
jj = jc_bgn; jj < jc_mid; jj++, // drinving index
j2++, j3++,
j4 += nrow_src0, j5 += nrow_src1) {
blas_axpy(nrow0, none, src_pt2 + j4, 1, // transposed
dst_pt + j2, dst_row);
blas_axpy(nrow1, none, src_pt3 + j5, 1, // transposed
dst_pt + j3, dst_row);
}
}
}
{
int jj, j0, j1, j2, j3, j4, j5;
const int nrow_src0 = src_mtrx->nrowBlock(iblock0, jblock1);
const int nrow_src1 = src_mtrx->nrowBlock(iblock1, jblock1);
T *src_pt0 = src_mtrx->addrCoefBlock(iblock0, jblock1);
T *src_pt1 = src_mtrx->addrCoefBlock(iblock1, jblock1);
for (j5 = 0, j4 = nrow_src_offset,
j0 = ir_bgn + jc_mid * dst_row, // (ir_bgn,jc_mid)-(ir_mid,jc_end)
j1 = ir_mid + jc_mid * dst_row, // (ir_mid,jc_mid)-(ir_end,jc_end)
jj = jc_mid; jj < jc_end; jj++, // driving index
j0 += dst_row, j1 += dst_row ,
j4 += nrow_src0, j5 += nrow_src1) {
blas_axpy(nrow0, none, src_pt0 + j4, 1, dst_pt + j0, 1);
blas_axpy(nrow1, none, src_pt1 + j5, 1, dst_pt + j1, 1);
}
// lower part of Schur complement matrix
T *src_pt2 = src_mtrx->addrCoefBlock(jblock1, iblock0);
T *src_pt3 = src_mtrx->addrCoefBlock(jblock1, iblock1);
{
for (j5 = 0, j4 = nrow_src_offset,
j2 = jc_mid + ir_bgn * dst_row,//(ir_bgn,jc_mid)-(ir_mid,jc_end)
j3 = jc_mid + ir_mid * dst_row,//(ir_mid,jc_mid)-(ir_end,jc_end)
jj = jc_mid; jj < jc_end; jj++, // driving index
j2++, j3++,
j4 += nrow_src0, j5 += nrow_src1) {
blas_axpy(nrow0, none, src_pt2 + j4, 1, dst_pt + j2, dst_row);
blas_axpy(nrow1, none, src_pt3 + j5, 1, dst_pt + j3, dst_row);
}
}
}
} // if ((jblock0 + 1) == jblock1) {
else if (jblock0 == jblock1) {
int jj, j0, j1, j2, j3, j4, j5;
const int nrow_src0 = src_mtrx->nrowBlock(iblock0, jblock0);
const int nrow_src1 = src_mtrx->nrowBlock(iblock1, jblock0);
T *src_pt0 = src_mtrx->addrCoefBlock(iblock0, jblock0);
T *src_pt1 = src_mtrx->addrCoefBlock(iblock1, jblock0);
for (j5 = ncol_src_offset * nrow_src1,
j4 = nrow_src_offset + ncol_src_offset * nrow_src0,
j0 = ir_bgn + jc_bgn * dst_row, // (ir_bgn,jc_bgn)-(ir_mid,jc_end)
j1 = ir_mid + jc_bgn * dst_row, // (ir_mid,jc_bgn)-(ir_end,jc_end)
jj = jc_bgn; jj < jc_end; jj++, // driving index
j0 += dst_row, j1 += dst_row,
j4 += nrow_src0, j5 += nrow_src1) {
blas_axpy(nrow0, none, src_pt0 + j4, 1, dst_pt + j0, 1);
blas_axpy(nrow1, none, src_pt1 + j5, 1, dst_pt + j1, 1);
}
// lower part of Schur complement matrix
T *src_pt2 = src_mtrx->addrCoefBlock(jblock0, iblock0);
T *src_pt3 = src_mtrx->addrCoefBlock(jblock0, iblock1);
if (iblock1 == jblock0) {
for (j5 = ncol_src_offset,
j4 = nrow_src_offset + ncol_src_offset * nrow_src0,
j2 = jc_bgn + ir_bgn * dst_row,//(ir_bgn,jc_bgn)-(ir_mid,jc_end)
j3 = jc_bgn + ir_mid * dst_row,//(ir_mid,jc_bgn)-(ir_end,jc_end)
jj = jc_bgn; jj < jc_end; jj++, // driving index
j2++, j3++,
j4 += nrow_src0, j5++) {
blas_axpy(nrow0, none, src_pt2 + j4, 1, // transposed
dst_pt + j2, dst_row);
blas_axpy(nrow1, none, src_pt3 + j5, nrow_src1, // both in the
dst_pt + j3, dst_row); // diagonal
}
}
else {
for (j5 = ncol_src_offset * nrow_src1,
j4 = nrow_src_offset + ncol_src_offset * nrow_src0,
j2 = jc_bgn + ir_bgn * dst_row,//(ir_bgn,jc_bgn)-(ir_mid,jc_end)
j3 = jc_bgn + ir_mid * dst_row,//(ir_mid,jc_bgn)-(ir_end,jc_end)
jj = jc_bgn; jj < jc_end; jj++, // driving index
j2++, j3++,
j4 += nrow_src0, j5 += nrow_src1) {
blas_axpy(nrow0, none, src_pt2 + j4, 1, dst_pt + j2, dst_row);
blas_axpy(nrow1, none, src_pt3 + j5, 1, dst_pt + j3, dst_row);
}
}
}
else {
diss_printf(arg->verbose, arg->fp,
"%s %d : bad block indices in column : %d %d\n",
__FILE__, __LINE__, jblock0, jblock1);
}
}
else if (iblock0 == iblock1) {
if ((jblock0 + 1) == jblock1) {
const int jc_mid_src = src_mtrx->IndexBlock(jblock1);
const int ncol0 = jc_mid_src - jc_bgn_src;
const int jc_mid = jc_bgn + ncol0;
{
int jj, j0, j1, j2;
const int nrow_src = src_mtrx->nrowBlock(iblock0, jblock0);
T *src_pt = src_mtrx->addrCoefBlock(iblock0, jblock0);
for (j2 = nrow_src_offset + ncol_src_offset * nrow_src,
j0 = ir_bgn + jc_bgn * dst_row, // (ir_bgn,jc_bgn)-(ir_end,jc_mid)
jj = jc_bgn; jj < jc_mid; jj++, // driving index
j0 += dst_row, j2 += nrow_src) {
blas_axpy(nrow, none, src_pt + j2, 1, dst_pt + j0, 1);
}
// lower part of Schur complement matrix
T *src_pt2 = src_mtrx->addrCoefBlock(jblock0, iblock0);
if (iblock0 == jblock0) {
for (j2 = ncol_src_offset + nrow_src_offset * nrow_src,
j1 = jc_bgn + ir_bgn * dst_row,//(ir_bgn,jc_bgn)-(ir_end,jc_mid)
jj = jc_bgn; jj < jc_mid; jj++, // driving index
j1++, j2++) {
blas_axpy(nrow, none, src_pt2 + j2, nrow_src,
dst_pt + j1, dst_row);
}
}
else {
for (j2 = nrow_src_offset + ncol_src_offset * nrow_src,
j1 = jc_bgn + ir_bgn * dst_row,//(ir_bgn,jc_bgn)-(ir_end,jc_mid)
jj = jc_bgn; jj < jc_mid; jj++, // driving index
j1++, j2 += nrow_src) {
blas_axpy(nrow, none, src_pt2 + j2, 1,
dst_pt + j1, dst_row);
}
}
}
{
int jj, j0, j1, j2;
const int nrow_src = src_mtrx->nrowBlock(iblock0, jblock1);
T *src_pt = src_mtrx->addrCoefBlock(iblock0, jblock1);
T *src_pt2 = src_mtrx->addrCoefBlock(jblock1, iblock0);
for (j2 = nrow_src_offset,
j0 = ir_bgn + jc_mid * dst_row, // (ir_bgn,jc_mid)-(ir_end,jc_end)
j1 = jc_mid + ir_bgn * dst_row,//T(ir_bgn,jc_mid)-(ir_end,jc_end)
jj = jc_mid; jj < jc_end; jj++, // driving index
j0 += dst_row, j1++, j2 += nrow_src) {
blas_axpy(nrow, none, src_pt + j2, 1, dst_pt + j0, 1);
// lower part of Schur complement matrix
blas_axpy(nrow, none, src_pt2 + j2, 1, dst_pt + j1, dst_row);
}
}
}
else {
int jj, j0, j1, j2;
const int nrow_src = src_mtrx->nrowBlock(iblock0, jblock0);
T *src_pt = src_mtrx->addrCoefBlock(iblock0, jblock0);
for (j2 = nrow_src_offset + ncol_src_offset * nrow_src,
j0 = ir_bgn + jc_bgn * dst_row, // (ir_bgn,jc_bgn)-(ir_end,jc_end)
jj = jc_bgn; jj < jc_end; jj++, // driving index
j0 += dst_row, j2 += nrow_src) {
blas_axpy(nrow, none, src_pt + j2, 1, dst_pt + j0, 1);
}
T *src_pt2 = src_mtrx->addrCoefBlock(jblock0, iblock0);
if (iblock0 == jblock0) {
for (j2 = ncol_src_offset + nrow_src_offset * nrow_src, //trans
j1 = jc_bgn + ir_bgn * dst_row, //T(ir_bgn,jc_bgn)-(ir_end,jc_end)
jj = jc_bgn; jj < jc_end; jj++, // driving index
j1++, j2++) {
blas_axpy(nrow, none, src_pt2 + j2, nrow_src,
dst_pt + j1, dst_row);
}
}
else {
for (j2 = nrow_src_offset + ncol_src_offset * nrow_src,
j1 = jc_bgn + ir_bgn * dst_row, //T(ir_bgn,jc_bgn)-(ir_end,jc_end)
jj = jc_bgn; jj < jc_end; jj++, // driving index
j1++, j2 += nrow_src) {
blas_axpy(nrow, none, src_pt2 + j2, 1, dst_pt + j1, dst_row);
}
}
}
} // if ((jblock0 + 1) == jblock1)
else {
diss_printf(arg->verbose, arg->fp,
"%s %d : bad block indices in row : %d %d\n",
__FILE__, __LINE__, iblock0, iblock1);
}
}
template
void dsub_unsym2diag(C_Dsub_task *arg);
template
void dsub_unsym2diag(C_Dsub_task *arg);
template
void dsub_unsym2diag >(C_Dsub_task > *arg);
template
void dsub_unsym2diag >(C_Dsub_task > *arg);
template
void dsub_unsym2diag(C_Dsub_task *arg);
template
void dsub_unsym2diag >(C_Dsub_task > *arg);
// end of template function dsub_unsym2diag
template
void dsub_sym2rct(C_Dsub_task *arg)
{
const int ir_bgn = arg->ir_bgn;
const int ir_end = arg->ir_end;
const int jc_bgn = arg->jc_bgn;
const int jc_end = arg->jc_end;
const int ir_bgn_src = arg->ir_bgn_src;
const int jc_bgn_src = arg->jc_bgn_src;
// const int dst_row = arg->dst_row;
T *dst_pt = arg->dst_pt->addrCoefBlock(arg->ir_block, arg->jc_block);
const int dst_row = arg->dst_pt->nrowBlock(arg->ir_block);
SquareBlockMatrix *src_mtrx = arg->src_pt;
const int nrow = ir_end - ir_bgn;
const int ncol = jc_end - jc_bgn;
const int iblock0 = src_mtrx->BlockIndex(ir_bgn_src);
const int iblock1 = src_mtrx->BlockIndex(ir_bgn_src + nrow - 1);
const int nrow_src_offset = src_mtrx->BlockOffset(ir_bgn_src);
const int jblock0 = src_mtrx->BlockIndex(jc_bgn_src);
const int jblock1 = src_mtrx->BlockIndex(jc_bgn_src + ncol - 1);
const int ncol_src_offset = src_mtrx->BlockOffset(jc_bgn_src);
const T none(-1.0);
if (iblock0 < iblock1) {
// decomposition is defined by src block with SIZE_B1
if ((jblock0 + 1) == jblock1) {
const int jc_mid = jc_bgn + (src_mtrx->IndexBlock(jblock1) - jc_bgn_src);
int ir_start = ir_bgn;
{
int jj, j0, j1;
const int nrow_src = src_mtrx->nrowBlock(iblock0, jblock0); // SIZE_B1?
const int nnrow = nrow_src - nrow_src_offset;
T *src_pt;
src_pt = src_mtrx->addrCoefBlock(iblock0, jblock0);
for (j1 = nrow_src_offset + ncol_src_offset * nrow_src,
j0 = ir_start + jc_bgn * dst_row, // ( ,jc_bgn)-( +nnrow,jc_mid)
jj = jc_bgn; jj < jc_mid; jj++, // drinving index
j0 += dst_row, j1 += nrow_src) {
blas_axpy(nnrow, none, src_pt + j1, 1, dst_pt + j0, 1);
}
src_pt = src_mtrx->addrCoefBlock(iblock0, jblock1);
for (j1 = nrow_src_offset,
j0 = ir_start + jc_mid * dst_row, // ( ,jc_mid)-( +nnrow,jc_end)
jj = jc_mid; jj < jc_end; jj++, // drinving index
j0 += dst_row, j1 += nrow_src) {
blas_axpy(nnrow, none, src_pt + j1, 1, dst_pt + j0, 1);
}
ir_start += nnrow;
}
for (int iblock = iblock0 + 1; iblock < iblock1; iblock++) {
int jj, j0, j1;
const int nrow_src = src_mtrx->nrowBlock(iblock, jblock0); // SIZE_B1?
T *src_pt;
src_pt = src_mtrx->addrCoefBlock(iblock, jblock0);
for (j1 = ncol_src_offset * nrow_src,
j0 = ir_start + jc_bgn * dst_row, // ( ,jc_bgn)-( +SIZE_B1,jc_mid)
jj = jc_bgn; jj < jc_mid; jj++, // drinving index
j0 += dst_row, j1 += nrow_src) {
blas_axpy(nrow_src, none, src_pt + j1, 1, dst_pt + j0, 1);
}
src_pt = src_mtrx->addrCoefBlock(iblock, jblock1);
for (j1 = 0,
j0 = ir_start + jc_mid * dst_row, // ( ,jc_mid)-( +SIZE_B1,jc_end)
jj = jc_mid; jj < jc_end; jj++, // drinving index
j0 += dst_row, j1 += nrow_src) {
blas_axpy(nrow_src, none, src_pt + j1, 1, dst_pt + j0, 1);
}
ir_start += nrow_src;
}
{
int jj, j0, j1;
const int nrow_src = src_mtrx->nrowBlock(iblock1, jblock0);
const int nnrow = ir_bgn_src + nrow - src_mtrx->IndexBlock(iblock1);
T *src_pt;
src_pt = src_mtrx->addrCoefBlock(iblock1, jblock0);
for (j1 = ncol_src_offset * nrow_src,
j0 = ir_start + jc_bgn * dst_row, // ( ,jc_bgn)-( +nnrow,jc_mid)
jj = jc_bgn; jj < jc_mid; jj++, // drinving index
j0 += dst_row, j1 += nrow_src) {
blas_axpy(nnrow, none, src_pt + j1, 1, dst_pt + j0, 1);
}
src_pt = src_mtrx->addrCoefBlock(iblock1, jblock1);
for (j1 = 0,
j0 = ir_start + jc_mid * dst_row, // ( ,jc_bgn)-( +nnrow,jc_mid)
jj = jc_mid; jj < jc_end; jj++, // drinving index
j0 += dst_row, j1 += nrow_src) {
blas_axpy(nnrow, none, src_pt + j1, 1, dst_pt + j0, 1);
}
}
}
else if (jblock0 == jblock1) {
int ir_start = ir_bgn;
{
int jj, j0, j1;
const int nrow_src = src_mtrx->nrowBlock(iblock0, jblock0);
const int nnrow = nrow_src - nrow_src_offset;
T *src_pt = src_mtrx->addrCoefBlock(iblock0, jblock0);
for (j1 = nrow_src_offset + ncol_src_offset * nrow_src,
j0 = ir_start + jc_bgn * dst_row, // ( ,jc_bgn)-( +nnrow,jc_end)
jj = jc_bgn; jj < jc_end; jj++, // drinving index
j0 += dst_row, j1 += nrow_src) {
blas_axpy(nnrow, none, src_pt + j1, 1, dst_pt + j0, 1);
}
ir_start += nnrow;
}
for (int iblock = iblock0 + 1; iblock < iblock1; iblock++) {
int jj, j0, j1;
const int nrow_src = src_mtrx->nrowBlock(iblock, jblock0);
T *src_pt = src_mtrx->addrCoefBlock(iblock, jblock0);
for (j1 = ncol_src_offset * nrow_src,
j0 = ir_start + jc_bgn * dst_row, // ( ,jc_bgn)-( +SIZE_B1,jc_end)
jj = jc_bgn; jj < jc_end; jj++, // drinving index
j0 += dst_row, j1 += nrow_src) {
blas_axpy(nrow_src, none, src_pt + j1, 1, dst_pt + j0, 1);
}
ir_start += nrow_src;
}
{
int jj, j0, j1;
const int nrow_src = src_mtrx->nrowBlock(iblock1, jblock0);
// const int itmp = (ir_bgn_src + nrow) % SIZE_B1;
// const int nnrow = (itmp == 0) ? SIZE_B1 : itmp;
const int nnrow = ir_bgn_src + nrow - src_mtrx->IndexBlock(iblock1);
T *src_pt = src_mtrx->addrCoefBlock(iblock1, jblock0);
for (j1 = ncol_src_offset * nrow_src,
j0 = ir_start + jc_bgn * dst_row, // ( ,jc_bgn)-( +nnrow,jc_end)
jj = jc_bgn; jj < jc_end; jj++, // drinving index
j0 += dst_row, j1 += nrow_src) {
blas_axpy(nnrow, none, src_pt + j1, 1, dst_pt + j0, 1);
}
}
}
else {
diss_printf(arg->verbose, arg->fp,
"%s %d : bad block indices in column : %d %d\n",
__FILE__, __LINE__, jblock0, jblock1);
}
} // if (iblock0 < iblock1)
else {
if ((jblock0 + 1) == jblock1) {
const int jc_mid_src = src_mtrx->IndexBlock(jblock1);
const int ncol0 = jc_mid_src - jc_bgn_src;
const int jc_mid = jc_bgn + ncol0;
{
int jj, j0, j1;
const int nrow_src = src_mtrx->nrowBlock(iblock0, jblock0);
T *src_pt = src_mtrx->addrCoefBlock(iblock0, jblock0);
for (j1 = nrow_src_offset + ncol_src_offset * nrow_src,
j0 = ir_bgn + jc_bgn * dst_row, // (ir_bgn,jc_bgn)-(ir_end,jc_mid)
jj = jc_bgn; jj < jc_mid; jj++, // driving index
j0 += dst_row, j1 += nrow_src) {
blas_axpy(nrow, none, src_pt + j1, 1, dst_pt + j0, 1);
}
}
{
int jj, j0, j1;
const int nrow_src = src_mtrx->nrowBlock(iblock0, jblock1);
T *src_pt = src_mtrx->addrCoefBlock(iblock0, jblock1);
for (j1 = nrow_src_offset,
j0 = ir_bgn + jc_mid * dst_row, // (ir_bgn,jc_mid)-(ir_end,jc_end)
jj = jc_mid; jj < jc_end; jj++, // driving index
j0 += dst_row, j1 += nrow_src) {
blas_axpy(nrow, none, src_pt + j1, 1, dst_pt + j0, 1);
}
}
}
else if (jblock0 == jblock1) {
int jj, j0, j1;
const int nrow_src = src_mtrx->nrowBlock(iblock0, jblock0);
T *src_pt = src_mtrx->addrCoefBlock(iblock0, jblock0);
for (j1 = nrow_src_offset + ncol_src_offset * nrow_src,
j0 = ir_bgn + jc_bgn * dst_row, // (ir_bgn,jc_bgn)-(ir_end,jc_end)
jj = jc_bgn; jj < jc_end; jj++, // driving index
j0 += dst_row, j1 += nrow_src) {
blas_axpy(nrow, none, src_pt + j1, 1, dst_pt + j0, 1);
}
}
else {
diss_printf(arg->verbose, arg->fp,
"%s %d : bad block indices in column : %d %d\n",
__FILE__, __LINE__, jblock0, jblock1);
}
} // if (iblock0 < iblock1)
}
template
void dsub_sym2rct(C_Dsub_task *arg);
template
void dsub_sym2rct(C_Dsub_task *arg);
template
void dsub_sym2rct >(C_Dsub_task > *arg);
template
void dsub_sym2rct >(C_Dsub_task > *arg);
template
void dsub_sym2rct(C_Dsub_task *arg);
template
void dsub_sym2rct >(C_Dsub_task > *arg);
// end of template function dsub_sym2rct
template
void dsub_unsym2rct(C_Dsub_task *arg)
{
const int ir_bgn = arg->ir_bgn;
const int ir_end = arg->ir_end;
const int jc_bgn = arg->jc_bgn;
const int jc_end = arg->jc_end;
const int ir_bgn_src = arg->ir_bgn_src;
const int jc_bgn_src = arg->jc_bgn_src;
// const int dst_row = arg->dst_row;
T *dst_pt = arg->dst_pt->addrCoefBlock(arg->ir_block, arg->jc_block);
T *dst_pt2 = arg->dst_pt2->addrCoefBlock(arg->ir_block, arg->jc_block);
const int dst_row = arg->dst_pt->nrowBlock(arg->ir_block);
SquareBlockMatrix *src_mtrx = arg->src_pt;
const int nrow = ir_end - ir_bgn;
const int ncol = jc_end - jc_bgn;
const int iblock0 = src_mtrx->BlockIndex(ir_bgn_src);
const int iblock1 = src_mtrx->BlockIndex(ir_bgn_src + nrow - 1);
const int nrow_src_offset = src_mtrx->BlockOffset(ir_bgn_src);
const int jblock0 = src_mtrx->BlockIndex(jc_bgn_src);
const int jblock1 = src_mtrx->BlockIndex(jc_bgn_src + ncol - 1);
const int ncol_src_offset = src_mtrx->BlockOffset(jc_bgn_src);
const T none(-1.0);
if (iblock0 < iblock1) {
// decomposition is defined by src block with SIZE_B1
if ((jblock0 + 1) == jblock1) {
const int jc_mid = jc_bgn + (src_mtrx->IndexBlock(jblock1) - jc_bgn_src);
int ir_start = ir_bgn;
{
int jj, j0, j1, j2;
const int nrow_src = src_mtrx->nrowBlock(iblock0, jblock0); // SIZE_B1?
const int nnrow = nrow_src - nrow_src_offset;
T *src_pt0, *src_pt1;
src_pt0 = src_mtrx->addrCoefBlock(iblock0, jblock0);
src_pt1 = src_mtrx->addrCoefBlock(jblock0, iblock0);
if (jblock0 == iblock0) {
for (j1 = nrow_src_offset + ncol_src_offset * nrow_src,
j2 = ncol_src_offset + nrow_src_offset * nrow_src, // transposed
j0 = ir_start + jc_bgn * dst_row,//( ,jc_bgn)-( +nnrow,jc_mid)
jj = jc_bgn; jj < jc_mid; jj++, // drinving index
j0 += dst_row, j1 += nrow_src, j2++) {
blas_axpy(nnrow, none, src_pt0 + j1, 1, dst_pt + j0, 1);
blas_axpy(nnrow, none, src_pt1 + j2, nrow_src, dst_pt2 + j0, 1);
}
}
else {
for (j1 = nrow_src_offset + ncol_src_offset * nrow_src,
j0 = ir_start + jc_bgn * dst_row,//( ,jc_bgn)-( +nnrow,jc_mid)
jj = jc_bgn; jj < jc_mid; jj++, // drinving index
j0 += dst_row, j1 += nrow_src) {
blas_axpy(nnrow, none, src_pt0 + j1, 1, dst_pt + j0, 1);
blas_axpy(nnrow, none, src_pt1 + j1, 1, dst_pt2 + j0, 1);
}
}
src_pt0 = src_mtrx->addrCoefBlock(iblock0, jblock1);
src_pt1 = src_mtrx->addrCoefBlock(jblock1, iblock0);
if (jblock1 == iblock0) {
for (j1 = nrow_src_offset,
j2 = nrow_src_offset * nrow_src, // transposed
j0 = ir_start + jc_mid * dst_row,//( ,jc_mid)-( +nnrow,jc_end)
jj = jc_mid; jj < jc_end; jj++, // drinving index
j0 += dst_row, j1 += nrow_src, j2++) {
blas_axpy(nnrow, none, src_pt0 + j1, 1, dst_pt + j0, 1);
blas_axpy(nnrow, none, src_pt1 + j2, nrow_src, dst_pt2 + j0, 1);
}
}
else {
for (j1 = nrow_src_offset,
j0 = ir_start + jc_mid * dst_row,//( ,jc_mid)-( +nnrow,jc_end)
jj = jc_mid; jj < jc_end; jj++, // drinving index
j0 += dst_row, j1 += nrow_src) {
blas_axpy(nnrow, none, src_pt0 + j1, 1, dst_pt + j0, 1);
blas_axpy(nnrow, none, src_pt1 + j1, 1, dst_pt2 + j0, 1);
}
}
ir_start += nnrow;
}
for (int iblock = iblock0 + 1; iblock < iblock1; iblock++) {
int jj, j0, j1, j2;
const int nrow_src = src_mtrx->nrowBlock(iblock, jblock0); // SIZE_B1?
T *src_pt0, *src_pt1;
src_pt0 = src_mtrx->addrCoefBlock(iblock, jblock0);
src_pt1 = src_mtrx->addrCoefBlock(jblock0, iblock);
if (jblock0 == iblock) {
for (j1 = ncol_src_offset * nrow_src,
j2 = ncol_src_offset, // transposed
j0 = ir_start + jc_bgn * dst_row,//( ,jc_bgn)-( +SIZE_B1,jc_mid)
jj = jc_bgn; jj < jc_mid; jj++, // drinving index
j0 += dst_row, j1 += nrow_src, j2++) {
blas_axpy(nrow_src, none, src_pt0 + j1, 1,
dst_pt + j0, 1);
blas_axpy(nrow_src, none, src_pt1 + j2, nrow_src,
dst_pt2 + j0, 1);
}
}
else {
for (j1 = ncol_src_offset * nrow_src,
j0 = ir_start + jc_bgn * dst_row,//( ,jc_bgn)-( +SIZE_B1,jc_mid)
jj = jc_bgn; jj < jc_mid; jj++, // drinving index
j0 += dst_row, j1 += nrow_src) {
blas_axpy(nrow_src, none, src_pt0 + j1, 1, dst_pt + j0, 1);
blas_axpy(nrow_src, none, src_pt1 + j1, 1, dst_pt2 + j0, 1);
}
}
src_pt0 = src_mtrx->addrCoefBlock(iblock, jblock1);
src_pt1 = src_mtrx->addrCoefBlock(jblock1, iblock);
if (jblock1 == iblock) {
for (j1 = 0,
j2 = 0,
j0 = ir_start + jc_mid * dst_row,//( ,jc_mid)-( +SIZE_B1,jc_end)
jj = jc_mid; jj < jc_end; jj++, // drinving index
j0 += dst_row, j1 += nrow_src, j2++) {
blas_axpy(nrow_src, none, src_pt0 + j1, 1,
dst_pt + j0, 1);
blas_axpy(nrow_src, none, src_pt1 + j2, nrow_src,
dst_pt2 + j0, 1);
}
}
else {
for (j1 = 0,
j0 = ir_start + jc_mid * dst_row,//( ,jc_mid)-( +SIZE_B1,jc_end)
jj = jc_mid; jj < jc_end; jj++, // drinving index
j0 += dst_row, j1 += nrow_src) {
blas_axpy(nrow_src, none, src_pt0 + j1, 1, dst_pt + j0, 1);
blas_axpy(nrow_src, none, src_pt1 + j1, 1, dst_pt2 + j0, 1);
}
}
ir_start += nrow_src;
}
{
int jj, j0, j1, j2;
const int nrow_src = src_mtrx->nrowBlock(iblock1, jblock0);
// const int itmp = (ir_bgn_src + nrow) % SIZE_B1;
// const int nnrow = (itmp == 0) ? SIZE_B1 : itmp;
const int nnrow = ir_bgn_src + nrow - src_mtrx->IndexBlock(iblock1);
T *src_pt0, *src_pt1;
src_pt0 = src_mtrx->addrCoefBlock(iblock1, jblock0);
src_pt1 = src_mtrx->addrCoefBlock(jblock0, iblock1);
if (jblock0 == iblock1) {
for (j1 = ncol_src_offset * nrow_src,
j2 = ncol_src_offset, // transposed
j0 = ir_start + jc_bgn * dst_row, // ( ,jc_bgn)-( +nnrow,jc_mid)
jj = jc_bgn; jj < jc_mid; jj++, // drinving index
j0 += dst_row, j1 += nrow_src, j2++) {
blas_axpy(nnrow, none, src_pt0 + j1, 1, dst_pt + j0, 1);
blas_axpy(nnrow, none, src_pt1 + j2, nrow_src, dst_pt2 + j0, 1);
}
}
else {
for (j1 = ncol_src_offset * nrow_src,
j0 = ir_start + jc_bgn * dst_row, // ( ,jc_bgn)-( +nnrow,jc_mid)
jj = jc_bgn; jj < jc_mid; jj++, // drinving index
j0 += dst_row, j1 += nrow_src) {
blas_axpy(nnrow, none, src_pt0 + j1, 1, dst_pt + j0, 1);
blas_axpy(nnrow, none, src_pt1 + j1, 1, dst_pt2 + j0, 1);
}
}
src_pt0 = src_mtrx->addrCoefBlock(iblock1, jblock1);
src_pt1 = src_mtrx->addrCoefBlock(jblock1, iblock1);
if (jblock1 == iblock1) {
for (j2 = 0,
j1 = 0, //
j0 = ir_start + jc_mid * dst_row, // ( ,jc_bgn)-( +nnrow,jc_mid)
jj = jc_mid; jj < jc_end; jj++, // drinving index
j0 += dst_row, j1 += nrow_src, j2++) {
blas_axpy(nnrow, none, src_pt0 + j1, 1, dst_pt + j0, 1);
blas_axpy(nnrow, none, src_pt1 + j2, nrow_src, dst_pt2 + j0, 1);
}
}
else {
for (j1 = 0,
j0 = ir_start + jc_mid * dst_row, // ( ,jc_bgn)-( +nnrow,jc_mid)
jj = jc_mid; jj < jc_end; jj++, // drinving index
j0 += dst_row, j1 += nrow_src) {
blas_axpy(nnrow, none, src_pt0 + j1, 1, dst_pt + j0, 1);
blas_axpy(nnrow, none, src_pt1 + j1, 1, dst_pt2 + j0, 1);
}
}
}
}
else if (jblock0 == jblock1) {
int ir_start = ir_bgn;
{
int jj, j0, j1, j2;
const int nrow_src = src_mtrx->nrowBlock(iblock0, jblock0);
const int nnrow = nrow_src - nrow_src_offset;
T *src_pt0 = src_mtrx->addrCoefBlock(iblock0, jblock0);
T *src_pt1 = src_mtrx->addrCoefBlock(jblock0, iblock0);
if (jblock0 == iblock0) {
for (j1 = nrow_src_offset + ncol_src_offset * nrow_src,
j2 = ncol_src_offset + nrow_src_offset * nrow_src, // transpopsed
j0 = ir_start + jc_bgn * dst_row, // ( ,jc_bgn)-( +nnrow,jc_end)
jj = jc_bgn; jj < jc_end; jj++, // drinving index
j0 += dst_row, j1 += nrow_src, j2++) {
blas_axpy(nnrow, none, src_pt0 + j1, 1, dst_pt + j0, 1);
blas_axpy(nnrow, none, src_pt1 + j2, nrow_src, dst_pt2 + j0, 1);
}
}
else {
for (j1 = nrow_src_offset + ncol_src_offset * nrow_src,
j0 = ir_start + jc_bgn * dst_row, // ( ,jc_bgn)-( +nnrow,jc_end)
jj = jc_bgn; jj < jc_end; jj++, // drinving index
j0 += dst_row, j1 += nrow_src) {
blas_axpy(nnrow, none, src_pt0 + j1, 1, dst_pt + j0, 1);
blas_axpy(nnrow, none, src_pt1 + j1, 1, dst_pt2 + j0, 1);
}
}
ir_start += nnrow;
}
for (int iblock = iblock0 + 1; iblock < iblock1; iblock++) {
int jj, j0, j1, j2;
const int nrow_src = src_mtrx->nrowBlock(iblock, jblock0);
T *src_pt0 = src_mtrx->addrCoefBlock(iblock, jblock0);
T *src_pt1 = src_mtrx->addrCoefBlock(jblock0, iblock);
if (jblock0 == iblock) {
for (j1 = ncol_src_offset * nrow_src,
j2 = ncol_src_offset, // transposed
j0 = ir_start + jc_bgn * dst_row,//( ,jc_bgn)-( +SIZE_B1,jc_end)
jj = jc_bgn; jj < jc_end; jj++, // drinving index
j0 += dst_row, j1 += nrow_src, j2++) {
blas_axpy(nrow_src, none, src_pt0 + j1, 1, dst_pt + j0, 1);
blas_axpy(nrow_src, none, src_pt1 + j2, nrow_src,
dst_pt2 + j0, 1);
}
}
else {
for (j1 = ncol_src_offset * nrow_src,
j0 = ir_start + jc_bgn * dst_row, // ( ,jc_bgn)-( +SIZE_B1,jc_end)
jj = jc_bgn; jj < jc_end; jj++, // drinving index
j0 += dst_row, j1 += nrow_src) {
blas_axpy(nrow_src, none, src_pt0 + j1, 1, dst_pt + j0, 1);
blas_axpy(nrow_src, none, src_pt1 + j1, 1, dst_pt2 + j0, 1);
}
}
ir_start += nrow_src;
}
{
int jj, j0, j1, j2;
const int nrow_src = src_mtrx->nrowBlock(iblock1, jblock0);
// const int itmp = (ir_bgn_src + nrow) % SIZE_B1;
// const int nnrow = (itmp == 0) ? SIZE_B1 : itmp;
const int nnrow = ir_bgn_src + nrow - src_mtrx->IndexBlock(iblock1);
T *src_pt0 = src_mtrx->addrCoefBlock(iblock1, jblock0);
T *src_pt1 = src_mtrx->addrCoefBlock(jblock0, iblock1);
if (jblock0 == iblock1) {
for (j1 = ncol_src_offset * nrow_src,
j2 = ncol_src_offset, // transposed
j0 = ir_start + jc_bgn * dst_row, // ( ,jc_bgn)-( +nnrow,jc_end)
jj = jc_bgn; jj < jc_end; jj++, // drinving index
j0 += dst_row, j1 += nrow_src, j2++) {
blas_axpy(nnrow, none, src_pt0 + j1, 1, dst_pt + j0, 1);
blas_axpy(nnrow, none, src_pt1 + j2, nrow_src, dst_pt2 + j0, 1);
}
}
else {
for (j1 = ncol_src_offset * nrow_src,
j0 = ir_start + jc_bgn * dst_row, // ( ,jc_bgn)-( +nnrow,jc_end)
jj = jc_bgn; jj < jc_end; jj++, // drinving index
j0 += dst_row, j1 += nrow_src) {
blas_axpy(nnrow, none, src_pt0 + j1, 1, dst_pt + j0, 1);
blas_axpy(nnrow, none, src_pt1 + j1, 1, dst_pt2 + j0, 1);
}
}
}
}
else {
diss_printf(arg->verbose, arg->fp,
"%s %d : bad block indices in column : %d %d\n",
__FILE__, __LINE__, jblock0, jblock1);
}
}
else {
if ((jblock0 + 1) == jblock1) {
const int jc_mid_src = src_mtrx->IndexBlock(jblock1);
const int ncol0 = jc_mid_src - jc_bgn_src;
const int jc_mid = jc_bgn + ncol0;
{
int jj, j0, j1, j2;
const int nrow_src = src_mtrx->nrowBlock(iblock0, jblock0);
T *src_pt0 = src_mtrx->addrCoefBlock(iblock0, jblock0);
T *src_pt1 = src_mtrx->addrCoefBlock(jblock0, iblock0);
if (jblock0 == iblock0) {
for (j1 = nrow_src_offset + ncol_src_offset * nrow_src,
j2 = ncol_src_offset + nrow_src_offset * nrow_src, //transposed
j0 = ir_bgn + jc_bgn * dst_row, //(ir_bgn,jc_bgn)-(ir_end,jc_mid)
jj = jc_bgn; jj < jc_mid; jj++, // driving index
j0 += dst_row, j1 += nrow_src, j2++) {
blas_axpy(nrow, none, src_pt0 + j1, 1, dst_pt + j0, 1);
blas_axpy(nrow, none, src_pt1 + j2, nrow_src, dst_pt2 + j0, 1);
}
}
else {
for (j1 = nrow_src_offset + ncol_src_offset * nrow_src,
j0 = ir_bgn + jc_bgn * dst_row, //(ir_bgn,jc_bgn)-(ir_end,jc_mid)
jj = jc_bgn; jj < jc_mid; jj++, // driving index
j0 += dst_row, j1 += nrow_src) {
blas_axpy(nrow, none, src_pt0 + j1, 1, dst_pt + j0, 1);
blas_axpy(nrow, none, src_pt1 + j1, 1, dst_pt2 + j0, 1);
}
}
}
{
int jj, j0, j1, j2;
const int nrow_src = src_mtrx->nrowBlock(iblock0, jblock1);
T *src_pt0 = src_mtrx->addrCoefBlock(iblock0, jblock1);
T *src_pt1 = src_mtrx->addrCoefBlock(jblock1, iblock0);
if (jblock1 == iblock0) {
for (j1 = nrow_src_offset,
j2 = nrow_src_offset * nrow_src, //
j0 = ir_bgn + jc_mid * dst_row, //(ir_bgn,jc_mid)-(ir_end,jc_end)
jj = jc_mid; jj < jc_end; jj++, // driving index
j0 += dst_row, j1 += nrow_src, j2++) {
blas_axpy(nrow, none, src_pt0 + j1, 1, dst_pt + j0, 1);
blas_axpy(nrow, none, src_pt1 + j2, nrow_src, dst_pt2 + j0, 1);
}
}
else {
// distnation :
for (j1 = nrow_src_offset,
j0 = ir_bgn + jc_mid * dst_row, //(ir_bgn,jc_mid)-(ir_end,jc_end)
jj = jc_mid; jj < jc_end; jj++, // driving index
j0 += dst_row, j1 += nrow_src) {
blas_axpy(nrow, none, src_pt0 + j1, 1, dst_pt + j0, 1);
blas_axpy(nrow, none, src_pt1 + j1, 1, dst_pt2 + j0, 1);
}
}
}
}
else if (jblock0 == jblock1) {
int jj, j0, j1, j2;
const int nrow_src = src_mtrx->nrowBlock(iblock0, jblock0);
T *src_pt0 = src_mtrx->addrCoefBlock(iblock0, jblock0);
T *src_pt1 = src_mtrx->addrCoefBlock(jblock0, iblock0);
if (jblock0 == iblock0) {
for (j1 = nrow_src_offset + ncol_src_offset * nrow_src,
j2 = ncol_src_offset + nrow_src_offset * nrow_src,
j0 = ir_bgn + jc_bgn * dst_row, // (ir_bgn,jc_bgn)-(ir_end,jc_end)
jj = jc_bgn; jj < jc_end; jj++, // driving index
j0 += dst_row, j1 += nrow_src, j2++) {
blas_axpy(nrow, none, src_pt0 + j1, 1, dst_pt + j0, 1);
blas_axpy(nrow, none, src_pt1 + j2, nrow_src, dst_pt2 + j0, 1);
}
}
else {
for (j1 = nrow_src_offset + ncol_src_offset * nrow_src,
j0 = ir_bgn + jc_bgn * dst_row, // (ir_bgn,jc_bgn)-(ir_end,jc_end)
jj = jc_bgn; jj < jc_end; jj++, // driving index
j0 += dst_row, j1 += nrow_src) {
blas_axpy(nrow, none, src_pt0 + j1, 1, dst_pt + j0, 1);
blas_axpy(nrow, none, src_pt1 + j1, 1, dst_pt2 + j0, 1);
}
}
}
else {
diss_printf(arg->verbose, arg->fp,
"%s %d : bad block indices in column : %d %d\n",
__FILE__, __LINE__, jblock0, jblock1);
}
} // if (iblock0 < iblock1)
}
template
void dsub_unsym2rct(C_Dsub_task *arg);
template
void dsub_unsym2rct(C_Dsub_task *arg);
template
void dsub_unsym2rct >(C_Dsub_task > *arg);
template
void dsub_unsym2rct >(C_Dsub_task > *arg);
// end of template function dsub_unsym2rct
template
void dsub_unsym2rct(C_Dsub_task *arg);
template
void dsub_unsym2rct >(C_Dsub_task > *arg);
template
void dsub_sym2sym_diag_two(C_Dsub_task *arg)
{
if (arg->isSkip) {
return;
}
C_Dsub_task *tmp;
tmp = new C_Dsub_task(arg->atomic_size,
arg->atomic_id,
arg->ir_bgn,
arg->ir_end,
(-1), // jc_bgn
(-1), // jc_end
arg->ir_bgn_src,
(-1), // ir_bgn_src2
(-1), // jc_bgn_src
(-1), // jc_bgn_src2
arg->dst_row,
arg->dst_mtrx,
(RectBlockMatrix *)NULL, // dst_pt
arg->ir_block,
arg->jc_block,
(RectBlockMatrix *)NULL, // dst_pt2
(-1),
(-1),
arg->src_pt,
(SquareBlockMatrix