/*! \file C_DFullLDLt.cpp \brief block factorization routines LDL^t, LDU \author Atsushi Suzuki, Laboratoire Jacques-Louis Lions \date Apr. 22th 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 "Driver/C_threads_tasks.hpp" #include "Driver/C_KernDetect.hpp" #include "Driver/C_BlasRoutines.hpp" #include "Driver/DissectionDefault.hpp" #include "Compiler/arithmetic.hpp" #include "Algebra/VectorArray.hpp" #include "Compiler/DissectionIO.hpp" #include #ifdef BLAS_MKL #define MKL_DOMATCOPY #endif template void C_dupdateb_Schur_diag(void *arg_) { C_dupdateb_Schur_arg *arg = (C_dupdateb_Schur_arg *)arg_; const int task_position = arg->task_position; const int id_block = arg->id_block; const int id_level = arg->id_level; const int n = arg->n; const int nrow = arg->nrow; // size of diag. block whose matrix is factorized const int ncol = arg->ncol; // const int i1_block = arg->i1_block; const int ii_block = arg->ii_block; SquareBlockMatrix &D = *(arg->D); const int n0 = D.dim_kern_block(id_block); const T none(-1.0); const T one(1.0); if ((task_position % 2 == 1) && (id_level == 0)) { T *a = arg->a->addrCoefs(); //T *a = *(arg->a); D.copyBlockToArray(arg->ii_block, arg->ii_block, a, n); } if (arg->isSym) { // alpha=-1 // beta=1 C_gemm_symm(ncol, (nrow - n0), // nrow : zero padding is better ? none, // alpha D.addrCoefBlock(ii_block, i1_block), // lower transposed D.nrowBlock(ii_block, i1_block), D.addrCoefBlock(i1_block, ii_block), // upper D.nrowBlock(i1_block, ii_block), one, // beta, D.addrCoefBlock(ii_block, ii_block), // Schur D.nrowBlock(ii_block, ii_block)); } else { blas_gemm(CblasTrans, CblasNoTrans, ncol, ncol, (nrow - n0), // nrow : zero padding is better ? none, // alpha, D.addrCoefBlock(ii_block, i1_block), // lower transposed D.nrowBlock(ii_block, i1_block), D.addrCoefBlock(i1_block, ii_block), // upper D.nrowBlock(i1_block, ii_block), one, // beta, D.addrCoefBlock(ii_block, ii_block), // Schur D.nrowBlock(ii_block, ii_block)); } } template void C_dupdateb_Schur_diag(void *arg_); template void C_dupdateb_Schur_diag(void *arg_); template void C_dupdateb_Schur_diag >(void *arg_); template void C_dupdateb_Schur_diag >(void *arg_); template void C_dupdateb_Schur_diag(void *arg_); template void C_dupdateb_Schur_diag >(void *arg_); // template void C_dupdateb_Schur_offdiag(void *arg_) { C_dupdateb_Schur_arg *arg = (C_dupdateb_Schur_arg *)arg_; const int task_position = arg->task_position; const int id_block = arg->id_block; const int id_level = arg->id_level; const int n = arg->n; const int nrow = arg->nrow; const int ncol = arg->ncol; const int i1_block = arg->i1_block; const int ii_block = arg->ii_block; const int jj_block = arg->jj_block; SquareBlockMatrix &D = *(arg->D); const int n0 = D.dim_kern_block(id_block); const T none(-1.0); const T one(1.0); if ((task_position % 2 == 1) && (id_level == 0)) { T *a = arg->a->addrCoefs(); //T *a = *(arg->a); D.copyBlockToArray(arg->ii_block, arg->jj_block, a, n); if (!arg->isSym) { D.copyBlockToArray(arg->jj_block, arg->ii_block, a, n); } } blas_gemm(CblasTrans, CblasNoTrans, nrow, ncol, (nrow - n0), // none, // alpha, D.addrCoefBlock(ii_block, i1_block), // lower D.nrowBlock(ii_block, i1_block), D.addrCoefBlock(i1_block, jj_block), // upper D.nrowBlock(i1_block, jj_block), one, // beta, D.addrCoefBlock(ii_block, jj_block), // Schur D.nrowBlock(ii_block, jj_block)); if (!arg->isSym) { // S(jj,ii)-=L(jj)*U(ii) <==> S(jj,ii)^T-=L(jj)^T*U(ii)^T blas_gemm(CblasTrans, CblasNoTrans, nrow, // row of S^T ncol, (nrow - n0), // none, // alpha, D.addrCoefBlock(i1_block, ii_block), // upper^T D.nrowBlock(i1_block, ii_block), D.addrCoefBlock(jj_block, i1_block), // lower^T D.nrowBlock(jj_block, i1_block), one, // beta, D.addrCoefBlock(jj_block, ii_block), // Schur D.nrowBlock(jj_block, ii_block)); } } template void C_dupdateb_Schur_offdiag(void *arg_); template void C_dupdateb_Schur_offdiag(void *arg_); template void C_dupdateb_Schur_offdiag >(void *arg_); template void C_dupdateb_Schur_offdiag >(void *arg_); template void C_dupdateb_Schur_offdiag(void *arg_); template void C_dupdateb_Schur_offdiag >(void *arg_); // template void C_dfull_gauss_b(void *arg_) { const T zero(0.0); C_dfull_gauss_arg *arg = (C_dfull_gauss_arg *)arg_; const int task_position = arg->task_position; const int id_block = arg->id_block; const int id_level = arg->id_level; const int n = arg->n; const bool verbose = arg->verbose; FILE *fp = *(arg->fp); // int *nnn0 = arg->n0; int nn0; const int nrow = arg->nrow; const int i1_block = arg->i1_block; SquareBlockMatrix &D = *(arg->D); const int i1 = D.IndexBlock(i1_block); int *permute_block = new int[D.nrowBlock(i1_block)]; // block_size()] ; const int aug_dim = *(arg->aug_dim); const U eps_machine = *(arg->eps_machine); const double eps_piv = *(arg->eps_piv); // get smaller pivot of two children T *a_diag = D.addrCoefBlock(arg->i1_block, arg->i1_block); int nrow_block = D.nrowBlock(arg->i1_block, arg->i1_block); vector& permute = D.getPermute(); double pivot, pivot0, pivot1; vector& singIdx0 = D.getSingIdx0(); if (task_position % 2 == 1) { // copy the whole matrix for kernel detection and refactorization // if (*(arg->kernel_detection) || (id_level == 0)) { // 30 Jul.2014 ColumnMatrix &a = *(arg->a); a.init(n, n); // symmetrizie the first diagonal block : copy upper to lower if (arg->isSym) { for (int i = 0; i < nrow_block; i++) { for (int j = 0; j < i; j++) { // access lower a_diag[i + j * nrow_block] = a_diag[j + i * nrow_block]; } } } D.copyBlockToArray(arg->i1_block, arg->i1_block, a.addrCoefs(), n); // D.copyToArrayFull(a, n); } // if (id_level == 0) singIdx0.clear(); singIdx0.reserve(n); // singIdx0.resize(n, -1); D.set_dim_kern(0); // counting total number of null pivots among blocks // initialize permute[] for (int i = 0; i < n; i++) { permute[i] = i; } pivot0 = *(arg->pivot0); pivot1 = *(arg->pivot1); pivot = (pivot0 < pivot1 ? pivot0 : pivot1); *(arg->quit) = false; // default is to continue queue for refactorization } // if (task_position % 2 == 1) else { pivot = *(arg->pivot); } const int n0 = 0; double fop; if ((task_position % 2 == 1) && (nrow > aug_dim)) { bool flag_repeat_piv = true; // bool repeat_first = true; double eps_piv1 = eps_piv; int count_repeat = 0; ColumnMatrix a_diag1(nrow_block, nrow_block); while (flag_repeat_piv) { if (count_repeat == 0) { blas_copy((nrow_block * nrow_block), a_diag, 1, a_diag1.addrCoefs(), 1); } else { blas_copy((nrow_block * nrow_block), a_diag1.addrCoefs(), 1, a_diag, 1); } // if (count_repeat > 0) if (arg->isSym) { full_ldlt_permute(&nn0, n0, nrow, a_diag, nrow_block, &pivot, permute_block, eps_piv1, &fop); } else { full_ldu_permute(&nn0, n0, nrow, a_diag, nrow_block, &pivot, permute_block, eps_piv1, &fop); } // if (arg->isSym) if (((nrow - nn0) >= aug_dim) || (eps_piv1 < TOL_PIVOT)) { flag_repeat_piv = false; } else { eps_piv1 /= 10.0; count_repeat++; } } // while (flag_repeat_piv) if (eps_piv1 < TOL_PIVOT) { D.set_pivrelaxed(); } a_diag1.free(); if (count_repeat > 0) { diss_printf(verbose, fp, "%s %d : eps_piv = %g pivot = %g n0 = %d count_repeat = %d\n", __FILE__, __LINE__, eps_piv1, pivot, n0, count_repeat); } } // if ((id_level == 0) && (task_position % 2 == 1)) else { if (arg->isSym) { full_ldlt_permute(&nn0, n0, nrow, a_diag, nrow_block, &pivot, permute_block, eps_piv, &fop); } // if (arg->isSym) else { full_ldu_permute(&nn0, n0, nrow, a_diag, nrow_block, &pivot, permute_block, eps_piv, &fop); } } if (nn0 > 0) { diss_printf(verbose, fp, "%s %d : nd = %d : level = %d block = %d null = %d / %d\n", __FILE__, __LINE__, arg->nb, arg->id_level, arg->id_block, nn0, nrow); } // permute_block is defined by Fortran array, i.e. takes index starting 1 for (int i = i1; i < i1 + nrow; i++) { permute[i] = permute_block[i - i1] + i1; } // store singular nodes int sing_max = D.dim_kern(); // D.sing_max(); { int itmp = i1 + nrow - nn0; for (int i = 0; i < nn0; i++, itmp++, sing_max++) { // singIdx0[sing_max] = itmp; singIdx0.push_back(itmp); } D.set_dim_kern(sing_max); // total number of null pivots D.set_dim_kern_block(id_block, nn0); // #null pivots candidate in the block } if (task_position / 2 == 1) { { // scope for list tmp_idx list tmp_idx; for (int i = 0; i < sing_max; i++) { for (int j = -1; j <= 1; j++) { const int itmp = singIdx0[i] + j; if (itmp >= 0 && itmp < n) { tmp_idx.push_back(itmp); } } } tmp_idx.sort(); tmp_idx.unique(); if (sing_max > 0) { diss_printf(verbose, fp, "%s %d : %d : %g\n", __FILE__, __LINE__, arg->nb, pivot); } for (list::const_iterator it = tmp_idx.begin(); it != tmp_idx.end(); ++it) { bool dispflag = false; for (int j = 0; j < sing_max; j++) { if ((*it) == singIdx0[j]) { dispflag = true; } } diss_printf(verbose, fp, "%d %s %s\n", (*it), (dispflag ? "*" :":"), tostring(D.diag(*it)).c_str()); } } // nullifying diagonal entries for (int m = 0; m < sing_max; m++) { const int ii = singIdx0[m]; D.diag(ii) = zero; } bool refactorize = false; // default value // check dim of factorized matrix int dim_kern = 0; bool flagKernelDetect = true; if (sing_max > 0) { diss_printf(verbose, fp, "%s %d : C_dfull_gauss_b : id_level %d : nb = %d : %d / %d ", __FILE__, __LINE__, id_level, arg->nb, arg->id_block, arg->num_block); diss_printf(verbose, fp, "task_position = %d, i1 = %d , nrow = %d\n", task_position, i1, nrow); diss_printf(verbose, fp, "%s %d : sing_max = %d : ", __FILE__, __LINE__, sing_max); for (int i = 0; i < sing_max; i++) { diss_printf(verbose, fp, "%d ", singIdx0[i]); } diss_printf(verbose, fp, "\n"); if ((task_position == 3) && (sing_max + aug_dim) > nrow) { // if (task_position == 3) { *(arg->quit) = true; // refactorize is only applied for the root matrix diss_printf(verbose, fp, "%s %d : nonsingular part is too small %d : %d - %d : %d\n", __FILE__, __LINE__, aug_dim, nrow, nn0, sing_max); flagKernelDetect = false; dim_kern = sing_max; // nullify rows with all suspicious pivots D.set_KernelDetected(false); // kernel is unknown singIdx0.resize(sing_max); } } // if (sing_max > 0) else { flagKernelDetect = false; singIdx0.resize(0); dim_kern = 0; D.set_KernelDetected(true); } if (flagKernelDetect) { if (*(arg->kernel_detection) || (id_level == 0)) { singIdx0.resize(sing_max); dim_kern = dimKernDense(singIdx0, n, aug_dim, eps_machine, eps_piv, D, arg->a->addrCoefs(), //*(arg->a), refactorize, false, // isFullPermute arg->isSym, verbose, fp); diss_printf(verbose, fp, "%s %d : dim_kern = %d : singIdx0 = [", __FILE__, __LINE__, dim_kern); for (int i = 0; i < singIdx0.size(); i++) { diss_printf(verbose, fp, "%d ", singIdx0[i]); } diss_printf(verbose, fp, "]\n"); if (dim_kern == (-1)) { // refactorization happens in only the last level refactorize = true; D.set_KernelDetected(false); } else if (dim_kern != singIdx0.size()) { // 20 Feb.2017 dim_kern = sing_max; // nullify rows with all suspicious pivots D.set_KernelDetected(false); // kernel is unknown singIdx0.resize(sing_max); } else { D.set_KernelDetected(true); } } //else if (*(arg->kernel_detection) || (id_level == 0)) { else { diss_printf(verbose, fp, "%s %d : kernel detection will be done in the last\n", __FILE__, __LINE__); dim_kern = sing_max; // nullify rows with all suspicious pivots D.set_KernelDetected(false); // kernel is unknown singIdx0.resize(sing_max); } //else if (*(arg->kernel_detection) || (id_level == 0)) { } // if (flagKernelDetect) // if (sing_max > 0) if(arg->isSym) { D.freeLowerBlocks(); } if (refactorize){ //reset permutation for refactorization for (int i = 0; i < n; i++) { permute[i] = i; } diss_printf(verbose, fp, "%s %d : refactorization with whole diagonal pivots starts\n", __FILE__, __LINE__); *(arg->quit) = false; } else { // if (!refactorize) if (*(arg->kernel_detection) || (id_level == 0)) { // 30 Jul.2014 arg->a->free(); } if(id_level == 0) { *(arg->quit) = true; // refactorize is only applied for the root matrix } D.getSingIdx().resize(sing_max); for (int i = 0; i < sing_max; i++) { D.getSingIdx()[i] = permute[singIdx0[i]]; } D.set_lastPivot(pivot); D.set_dim_kern(dim_kern); D.set_rank(n - dim_kern); // } // if (refactorize) } // if (task_position / 2 == 1) else { if (nn0 > 0) { // nullifying diangol entries for (int ii = (i1 + nrow - nn0); ii < (i1 + nrow); ii++) { D.diag(ii) = zero; // a[ii * (n + 1)] = 0.0; } } // if (nn0 > 0) } // if (task_position / 2 == 1) *(arg->pivot) = pivot; // for passing information to other task delete [] permute_block; } template void C_dfull_gauss_b(void *arg_); template void C_dfull_gauss_b, double>(void *arg_); template void C_dfull_gauss_b(void *arg_); template void C_dfull_gauss_b, quadruple>(void *arg_); template void C_dfull_gauss_b(void *arg_); template void C_dfull_gauss_b, float>(void *arg_); // template void C_dinvDL_timesU(void *arg_) { const T one(1.0); C_dinvDL_timesU_arg *arg = (C_dinvDL_timesU_arg *)arg_; const int task_position = arg->task_position; const int id_level = arg->id_level; const int id_block = arg->id_block; const int n = arg->n; const int nrow = arg->nrow; const int ncol = arg->ncol; SquareBlockMatrix &D = *(arg->D); const int i1 = D.IndexBlock(arg->i1_block); T *a_diag = D.addrCoefBlock(arg->i1_block, arg->i1_block); T *a_upper = D.addrCoefBlock(arg->i1_block, arg->jj_block); const int nrow_block_diag = D.nrowBlock(arg->i1_block, arg->i1_block); const int nrow_block_upper= D.nrowBlock(arg->i1_block, arg->jj_block); if (arg->isSym) { D.allocateBlock(arg->jj_block, arg->i1_block); } T *a_lower = D.addrCoefBlock(arg->jj_block, arg->i1_block); const int nrow_block_lower = D.nrowBlock(arg->jj_block, arg->i1_block); vector& permute = D.getPermute(); const int n0 = D.dim_kern_block(id_block); // assuming to be allocated in the cache memory VectorArray a_tmp(nrow); if ((task_position % 2 == 1) && (id_level == 0)) { // T *a = *(arg->a); ColumnMatrix &a = *(arg->a); // copy a_upper D.copyBlockToArray(arg->i1_block, arg->jj_block, a.addrCoefs(), n); if (!arg->isSym) { // copy a_lower D.copyBlockToArray(arg->jj_block, arg->i1_block, a.addrCoefs(), n); } } { // copy upper to upper with permutation for (int j = 0; j < ncol; j++) { const int jn = j * nrow; for (int i = 0; i < nrow; i++) { const int ip = permute[i1 + i] - i1; a_tmp[i] = a_upper[ip + jn]; } blas_copy(nrow, a_tmp.addrCoefs(), 1, a_upper + jn, 1); } } if (!arg->isSym) { // copy transposed lower to transposed lower with permutation for (int j = 0; j < ncol; j++) { const int jn = j * nrow; for (int i = 0; i < nrow; i++) { const int ip = permute[i1 + i] - i1; a_tmp[i] = a_lower[ip + jn]; } blas_copy(nrow, a_tmp.addrCoefs(), 1, a_lower + jn, 1); } } blas_trsm(CblasLeft, CblasLower, CblasNoTrans, CblasUnit, (nrow - n0), // n0 : dim of suspicious pivots ncol, one, // alpha, a_diag, nrow_block_diag, // 3 Dec. 2015 a_upper, nrow_block_upper); // Dec. 2015 if (arg->isSym) { for (int j = 0; j < ncol; j++) { const int jn = j * nrow; blas_copy(nrow, a_upper + jn, 1, a_lower + jn, 1); } } else { // (A_{jj i1} U_{i1 i1}^-1)^T = U_{i1 i1}^{-T} A_{jj i1}^{T} blas_trsm(CblasLeft, CblasUpper, CblasTrans, CblasUnit, (nrow - n0), // n0 : dim of suspicious pivots ncol, one, // alpha, a_diag, nrow_block_diag, // 3 Dec.2015 a_lower, nrow_block_lower); // 3 Dec.2015 } for (int i = 0; i < nrow; i++) { const T aa = D.diag(i1 + i); for (int j = 0; j < ncol; j++) { a_upper[i + j * nrow] *= aa; } } } template void C_dinvDL_timesU(void *arg_); template void C_dinvDL_timesU(void *arg_); template void C_dinvDL_timesU >(void *arg_); template void C_dinvDL_timesU >(void *arg_); template void C_dinvDL_timesU(void *arg_); template void C_dinvDL_timesU >(void *arg_); // template void C_gauss_whole_pivot(void *arg_) { const T zero(0.0); const T one(1.0); C_dfull_gauss_arg *arg = (C_dfull_gauss_arg *)arg_; const int task_position = arg->task_position; const int n = arg->n; SquareBlockMatrix &D = *(arg->D); ColumnMatrix &a = *(arg->a); const double eps_piv = *(arg->eps_piv); double pivot = *(arg->pivot); // double *a_sym = D.addrCoefs(); vector& permute = D.getPermute(); vector& singIdx0 = D.getSingIdx0(); const int aug_dim = *(arg->aug_dim); const U eps_machine = *(arg->eps_machine); const bool verbose = arg->verbose; FILE *fp = *(arg->fp); int n1, dim_kern; if (task_position % 2 == 1) { ColumnMatrix aa(n, n); aa.copy(a); // blas_copy((n * n), a.addrCoefs(), 1, aa, 1); if (arg->isSym) { // copy upper to lower for rank-1 update procedure by dsyr('L', ) for (int j = 0; j < n; j++) { for (int i = 0; i < j; i++) { // aa[j + i * n] = aa[i + j * n]; aa(j, i) = aa(i, j); } } } const double pivot0 = *(arg->pivot0); const double pivot1 = *(arg->pivot1); pivot = (pivot0 < pivot1 ? pivot0 : pivot1); int n0 = 0; diss_printf(verbose, fp, "%s %d : C_gauss_whole_pivot : serial factroization : n = %d\n", __FILE__, __LINE__, n); int count_repeat = 0; bool flag_repeat_piv = true; double eps_piv1 = eps_piv; while (flag_repeat_piv) { if (count_repeat > 0) { aa.copy(a); // blas_copy((n * n), a.addrCoefs(), 1, aa.addrCoefs(), 1); if (arg->isSym) { // copy upper to lower for rank-1 update procedure by dsyr('L', ) for (int j = 0; j < n; j++) { for (int i = 0; i < j; i++) { aa[j + i * n] = aa[i + j * n]; } } } } // if (count_repeat > 0) n0 = 0; full_gauss3(&n0, aa.addrCoefs(), n, &pivot, &permute[0], arg->isSym, eps_piv1, verbose, fp); diss_printf(verbose, fp, "%s %d : C_gauss_whole_pivot : pivot = %g n0 = %d\n", __FILE__, __LINE__, pivot, n0); if (((n - n0) >= aug_dim) || (eps_piv1 < TOL_PIVOT)) { flag_repeat_piv = false; } else { eps_piv1 /= 10.0; count_repeat++; } } // while (flag_repeat_piv) diss_printf(verbose, fp, "%s %d : eps_pvi = %g pivot = %g n0 = %d count_repeat = %d\n", __FILE__, __LINE__, eps_piv1, pivot, n0, count_repeat); // D.unsetBlocked(); // D.copyFromArray(aa.addrCoefs(), n); // modification of lower blocks by removing D^-1 in the same mannar of // factorization by blocks if (!arg->isSym) { const int num_block = D.num_blocks(); for (int k = 0; k < num_block; k++) { for (int m = (k + 1); m < num_block; m++) { T *lower = D.addrCoefBlock(m, k); const int nrow = D.nrowBlock(m, k); const int ncol = D.ncolBlock(m, k); for (int i = 0; i < nrow; i++) { const T aa = one / D.addrCoefBlock(k, k)[i * (nrow + 1)]; for (int j = 0; j < ncol; j++) { lower[i + j * nrow] *= aa; } } } } } // dim_kern = 0; if (n0 > 0) { singIdx0.resize(n0); // singular nodes are continuously located from the last for (int i = 0; i < n0; i++) { singIdx0[i] = n - n0 + i; } dim_kern = dimKernDense(singIdx0, n, aug_dim, eps_machine, eps_piv, D, a.addrCoefs(), false, // refactorize true, // isFullPermute arg->isSym, verbose, fp); dim_kern = n0; diss_printf(verbose, fp, "%s %d : C_gauss_whole_pivot : dim_kern = %d\n", __FILE__, __LINE__, dim_kern); if (dim_kern == (-1)) { diss_printf(verbose, fp, "%s %d : strict diagonal pivot is not enough!\n", __FILE__, __LINE__); dim_kern = n0; D.set_KernelDetected(false); } else { n0 = dim_kern; D.set_KernelDetected(true); } } // if (n0 > 0) aa.free(); // need to move after copy to SquareBlockMatrix D(,) D.unsetBlocked(); // if (n0 > 0) { n1 = n - n0; // n - dim_kern; ==> regular part needs to be restored // nullify lower part corresponding to the suspicious pivots for (int j = 0; j < n; j++) { for (int i = n1; i < n; i++){ a[i + j * n] = zero; } } if (!arg->isSym) { for (int j = 0; j < n; j++) { for (int i = n1; i < n; i++){ a[j + i * n] = zero; } } } D.getSingIdx().resize(n0); for (int i = 0; i < n0; i++) { D.getSingIdx()[i] = permute[singIdx0[i]]; } // D.set_lastPivot(pivot); D.set_dim_kern(dim_kern); D.set_rank(n - dim_kern); } // if (n0 > 0) else { singIdx0.resize(0); D.getSingIdx().resize(0); D.set_KernelDetected(true); D.set_lastPivot(pivot); D.set_dim_kern(0); D.set_rank(n); } // if (n0 > 0) { int dim_kern1 = dim_kern; for (int k = (D.num_blocks() - 1); k >= 0 ; k--) { int nrow_local = D.nrowBlock(k); int dim_kern2 = nrow_local < dim_kern1 ? nrow_local : dim_kern1; D.set_dim_kern_block(k, dim_kern2); if (dim_kern1 > nrow_local) { dim_kern1 -= nrow_local; } else { dim_kern1 = 0; } } } #ifdef DEBUG_MATRIX_DFULLLDLT cout << arg->task_name << "n= " << n << endl; for (int i = 0; i < n; i++) { cout << " " << permute[i]; } cout << endl; for (int i = 0; i < ((n * (n + 1)) / 2); i++) { cout << " " << a_sym[i]; } cout << endl; #endif } // if (task_position % 2 == 1) *(arg->quit) = true; arg->a->free(); #ifdef DEBUG_MEMORY_ALLOC cerr << "C_gauss_whole_pivot : memory deallocate." << endl; // cout << "pivot " << pivot << endl; #endif *(arg->pivot) = pivot; // for passing information to other task } template void C_gauss_whole_pivot(void *arg_); template void C_gauss_whole_pivot, double>(void *arg_); template void C_gauss_whole_pivot(void *arg_); template void C_gauss_whole_pivot, quadruple>(void *arg_); template void C_gauss_whole_pivot(void *arg_); template void C_gauss_whole_pivot, float>(void *arg_); // template void C_dupdateb_Schur_offdiag_t(void *arg_) { C_dupdateb_Schur_arg *arg = (C_dupdateb_Schur_arg *)arg_; const int nrow = arg->nrow; const int ncol = arg->ncol; const int b_size = arg->b_size; SquareBlockMatrix &D = *(arg->D); const int i1 = D.IndexBlock(arg->i1_block); // arg->i1_block * SIZE_B1; const int ii = D.IndexBlock(arg->ii_block); // arg->ii_block * SIZE_B1; const int jj = D.IndexBlock(arg->jj_block); // arg->jj_block * SIZE_B1; FILE *fp = *(arg->fp); const bool verbose = arg->verbose; diss_printf(verbose, fp, "C_dupdate_Schur_offdiag_t : i1=%d ii=%d jj=%d nrow=%d ncol=%d b_size=%d\n", i1, ii, jj, nrow, ncol, b_size); diss_printf(verbose, fp, "no computation\n"); } template void C_dupdateb_Schur_offdiag_t(void *arg_); template void C_dupdateb_Schur_offdiag_t(void *arg_); template void C_dupdateb_Schur_offdiag_t >(void *arg_); template void C_dupdateb_Schur_offdiag_t >(void *arg_); template void C_dupdateb_Schur_offdiag_t(void *arg_); template void C_dupdateb_Schur_offdiag_t >(void *arg_); //