SuperLU Distributed 8.2.1
Distributed memory sparse direct solver
superlu_zdefs.h File Reference

Distributed SuperLU data types and function prototypes. More...

#include "superlu_defs.h"
#include "dcomplex.h"
Include dependency graph for superlu_zdefs.h:

Go to the source code of this file.

Classes

struct  zScalePermstruct_t
 
struct  zLocalLU_t
 
struct  zLUstruct_t
 
struct  pzgsmv_comm_t
 
struct  zSOLVEstruct_t
 
struct  zLUValSubBuf_t
 
struct  ztrf3Dpartition_t
 
struct  zscuBufs_t
 
struct  zdiagFactBufs_t
 

Macros

#define MAX_LOOKAHEADS   50
 

Functions

int_t scuStatUpdate (int_t knsupc, HyP_t *HyP, SCT_t *SCT, SuperLUStat_t *stat)
 
void zCreate_CompCol_Matrix_dist (SuperMatrix *, int_t, int_t, int_t, doublecomplex *, int_t *, int_t *, Stype_t, Dtype_t, Mtype_t)
 
void zCreate_CompRowLoc_Matrix_dist (SuperMatrix *, int_t, int_t, int_t, int_t, int_t, doublecomplex *, int_t *, int_t *, Stype_t, Dtype_t, Mtype_t)
 
void zCompRow_to_CompCol_dist (int_t, int_t, int_t, doublecomplex *, int_t *, int_t *, doublecomplex **, int_t **, int_t **)
 
int pzCompRow_loc_to_CompCol_global (int_t, SuperMatrix *, gridinfo_t *, SuperMatrix *)
 Gather A from the distributed compressed row format to global A in compressed column format. More...
 
void zCopy_CompCol_Matrix_dist (SuperMatrix *, SuperMatrix *)
 
void zCreate_Dense_Matrix_dist (SuperMatrix *, int_t, int_t, doublecomplex *, int_t, Stype_t, Dtype_t, Mtype_t)
 
void zCreate_SuperNode_Matrix_dist (SuperMatrix *, int_t, int_t, int_t, doublecomplex *, int_t *, int_t *, int_t *, int_t *, int_t *, Stype_t, Dtype_t, Mtype_t)
 
void zCopy_Dense_Matrix_dist (int_t, int_t, doublecomplex *, int_t, doublecomplex *, int_t)
 
void zallocateA_dist (int_t, int_t, doublecomplex **, int_t **, int_t **)
 
void zGenXtrue_dist (int_t, int_t, doublecomplex *, int_t)
 
void zFillRHS_dist (char *, int_t, doublecomplex *, int_t, SuperMatrix *, doublecomplex *, int_t)
 Let rhs[i] = sum of i-th row of A, so the solution vector is all 1's. More...
 
int zcreate_matrix (SuperMatrix *, int, doublecomplex **, int *, doublecomplex **, int *, FILE *, gridinfo_t *)
 
int zcreate_matrix_rb (SuperMatrix *, int, doublecomplex **, int *, doublecomplex **, int *, FILE *, gridinfo_t *)
 
int zcreate_matrix_dat (SuperMatrix *, int, doublecomplex **, int *, doublecomplex **, int *, FILE *, gridinfo_t *)
 
int zcreate_matrix_postfix (SuperMatrix *, int, doublecomplex **, int *, doublecomplex **, int *, FILE *, char *, gridinfo_t *)
 
void zScalePermstructInit (const int_t, const int_t, zScalePermstruct_t *)
 Allocate storage in ScalePermstruct. More...
 
void zScalePermstructFree (zScalePermstruct_t *)
 Deallocate ScalePermstruct. More...
 
void zgsequ_dist (SuperMatrix *, double *, double *, double *, double *, double *, int_t *)
 
double zlangs_dist (char *, SuperMatrix *)
 
void zlaqgs_dist (SuperMatrix *, double *, double *, double, double, double, char *)
 
void pzgsequ (SuperMatrix *, double *, double *, double *, double *, double *, int_t *, gridinfo_t *)
 
double pzlangs (char *, SuperMatrix *, gridinfo_t *)
 
void pzlaqgs (SuperMatrix *, double *, double *, double, double, double, char *)
 
int pzPermute_Dense_Matrix (int_t, int_t, int_t[], int_t[], doublecomplex[], int, doublecomplex[], int, int, gridinfo_t *)
 Permute the distributed dense matrix: B <= perm(X). perm[i] = j means the i-th row of X is in the j-th row of B. More...
 
int sp_ztrsv_dist (char *, char *, char *, SuperMatrix *, SuperMatrix *, doublecomplex *, int *)
 
int sp_zgemv_dist (char *, doublecomplex, SuperMatrix *, doublecomplex *, int, doublecomplex, doublecomplex *, int)
 SpGEMV. More...
 
int sp_zgemm_dist (char *, int, doublecomplex, SuperMatrix *, doublecomplex *, int, doublecomplex, doublecomplex *, int)
 
float zdistribute (superlu_dist_options_t *, int_t, SuperMatrix *, Glu_freeable_t *, zLUstruct_t *, gridinfo_t *)
 
void pzgssvx_ABglobal (superlu_dist_options_t *, SuperMatrix *, zScalePermstruct_t *, doublecomplex *, int, int, gridinfo_t *, zLUstruct_t *, double *, SuperLUStat_t *, int *)
 
float pzdistribute (superlu_dist_options_t *, int_t, SuperMatrix *, zScalePermstruct_t *, Glu_freeable_t *, zLUstruct_t *, gridinfo_t *)
 
void pzgssvx (superlu_dist_options_t *, SuperMatrix *, zScalePermstruct_t *, doublecomplex *, int, int, gridinfo_t *, zLUstruct_t *, zSOLVEstruct_t *, double *, SuperLUStat_t *, int *)
 
void pzCompute_Diag_Inv (int_t, zLUstruct_t *, gridinfo_t *, SuperLUStat_t *, int *)
 
int zSolveInit (superlu_dist_options_t *, SuperMatrix *, int_t[], int_t[], int_t, zLUstruct_t *, gridinfo_t *, zSOLVEstruct_t *)
 Initialize the data structure for the solution phase. More...
 
void zSolveFinalize (superlu_dist_options_t *, zSOLVEstruct_t *)
 Release the resources used for the solution phase. More...
 
void zDestroy_A3d_gathered_on_2d (zSOLVEstruct_t *, gridinfo3d_t *)
 
int_t pzgstrs_init (int_t, int_t, int_t, int_t, int_t[], int_t[], gridinfo_t *grid, Glu_persist_t *, zSOLVEstruct_t *)
 Destroy distributed L & U matrices. *‍/ void zDestroy_LU(int_t n, gridinfo_t *grid, zLUstruct_t *LUstruct) { int_t i, nb, nsupers; Glu_persist_t *Glu_persist = LUstruct->Glu_persist; zLocalLU_t *Llu = LUstruct->Llu;. More...
 
void pxgstrs_finalize (pxgstrs_comm_t *)
 
int zldperm_dist (int, int, int_t, int_t[], int_t[], doublecomplex[], int_t *, double[], double[])
 
int zstatic_schedule (superlu_dist_options_t *, int, int, zLUstruct_t *, gridinfo_t *, SuperLUStat_t *, int_t *, int_t *, int *)
 
void zLUstructInit (const int_t, zLUstruct_t *)
 Allocate storage in LUstruct. More...
 
void zLUstructFree (zLUstruct_t *)
 Deallocate LUstruct. More...
 
void zDestroy_LU (int_t, gridinfo_t *, zLUstruct_t *)
 Destroy distributed L & U matrices. More...
 
void zDestroy_Tree (int_t, gridinfo_t *, zLUstruct_t *)
 Destroy broadcast and reduction trees used in triangular solve. More...
 
void zscatter_l (int ib, int ljb, int nsupc, int_t iukp, int_t *xsup, int klst, int nbrow, int_t lptr, int temp_nbrow, int_t *usub, int_t *lsub, doublecomplex *tempv, int *indirect_thread, int *indirect2, int_t **Lrowind_bc_ptr, doublecomplex **Lnzval_bc_ptr, gridinfo_t *grid)
 
void zscatter_u (int ib, int jb, int nsupc, int_t iukp, int_t *xsup, int klst, int nbrow, int_t lptr, int temp_nbrow, int_t *lsub, int_t *usub, doublecomplex *tempv, int_t **Ufstnz_br_ptr, doublecomplex **Unzval_br_ptr, gridinfo_t *grid)
 
int_t pzgstrf (superlu_dist_options_t *, int, int, double anorm, zLUstruct_t *, gridinfo_t *, SuperLUStat_t *, int *)
 
void pzgstrs_Bglobal (superlu_dist_options_t *, int_t, zLUstruct_t *, gridinfo_t *, doublecomplex *, int_t, int, SuperLUStat_t *, int *)
 
void pzgstrs (superlu_dist_options_t *, int_t, zLUstruct_t *, zScalePermstruct_t *, gridinfo_t *, doublecomplex *, int_t, int_t, int_t, int, zSOLVEstruct_t *, SuperLUStat_t *, int *)
 
void pzgstrf2_trsm (superlu_dist_options_t *options, int_t k0, int_t k, double thresh, Glu_persist_t *, gridinfo_t *, zLocalLU_t *, MPI_Request *, int tag_ub, SuperLUStat_t *, int *info)
 
void pzgstrs2_omp (int_t k0, int_t k, Glu_persist_t *, gridinfo_t *, zLocalLU_t *, Ublock_info_t *, SuperLUStat_t *)
 
int_t pzReDistribute_B_to_X (doublecomplex *B, int_t m_loc, int nrhs, int_t ldb, int_t fst_row, int_t *ilsum, doublecomplex *x, zScalePermstruct_t *, Glu_persist_t *, gridinfo_t *, zSOLVEstruct_t *)
 
void zlsum_fmod (doublecomplex *, doublecomplex *, doublecomplex *, doublecomplex *, int, int, int_t, int *fmod, int_t, int_t, int_t, int_t *, gridinfo_t *, zLocalLU_t *, MPI_Request[], SuperLUStat_t *)
 
void zlsum_bmod (doublecomplex *, doublecomplex *, doublecomplex *, int, int_t, int *bmod, int_t *, Ucb_indptr_t **, int_t **, int_t *, gridinfo_t *, zLocalLU_t *, MPI_Request[], SuperLUStat_t *)
 
void zlsum_fmod_inv (doublecomplex *, doublecomplex *, doublecomplex *, doublecomplex *, int, int_t, int *fmod, int_t *, gridinfo_t *, zLocalLU_t *, SuperLUStat_t **, int_t *, int_t *, int_t, int_t, int_t, int_t, int, int)
 
void zlsum_fmod_inv_master (doublecomplex *, doublecomplex *, doublecomplex *, doublecomplex *, int, int, int_t, int *fmod, int_t, int_t *, gridinfo_t *, zLocalLU_t *, SuperLUStat_t **, int_t, int_t, int_t, int_t, int, int)
 
void zlsum_bmod_inv (doublecomplex *, doublecomplex *, doublecomplex *, doublecomplex *, int, int_t, int *bmod, int_t *, Ucb_indptr_t **, int_t **, int_t *, gridinfo_t *, zLocalLU_t *, SuperLUStat_t **, int_t *, int_t *, int_t, int_t, int, int)
 
void zlsum_bmod_inv_master (doublecomplex *, doublecomplex *, doublecomplex *, doublecomplex *, int, int_t, int *bmod, int_t *, Ucb_indptr_t **, int_t **, int_t *, gridinfo_t *, zLocalLU_t *, SuperLUStat_t **, int_t, int_t, int, int)
 
void zComputeLevelsets (int, int_t, gridinfo_t *, Glu_persist_t *, zLocalLU_t *, int_t *)
 
void pzgsrfs (superlu_dist_options_t *, int_t, SuperMatrix *, double, zLUstruct_t *, zScalePermstruct_t *, gridinfo_t *, doublecomplex[], int_t, doublecomplex[], int_t, int, zSOLVEstruct_t *, double *, SuperLUStat_t *, int *)
 
void pzgsrfs_ABXglobal (superlu_dist_options_t *, int_t, SuperMatrix *, double, zLUstruct_t *, gridinfo_t *, doublecomplex *, int_t, doublecomplex *, int_t, int, double *, SuperLUStat_t *, int *)
 
int pzgsmv_AXglobal_setup (SuperMatrix *, Glu_persist_t *, gridinfo_t *, int_t *, int_t *[], doublecomplex *[], int_t *[], int_t[])
 
int pzgsmv_AXglobal (int_t, int_t[], doublecomplex[], int_t[], doublecomplex[], doublecomplex[])
 
int pzgsmv_AXglobal_abs (int_t, int_t[], doublecomplex[], int_t[], doublecomplex[], double[])
 
void pzgsmv_init (SuperMatrix *, int_t *, gridinfo_t *, pzgsmv_comm_t *)
 
void pzgsmv (int_t, SuperMatrix *, gridinfo_t *, pzgsmv_comm_t *, doublecomplex x[], doublecomplex ax[])
 
void pzgsmv_finalize (pzgsmv_comm_t *)
 
doublecomplexdoublecomplexMalloc_dist (int_t)
 
doublecomplexdoublecomplexCalloc_dist (int_t)
 
double * doubleMalloc_dist (int_t)
 
double * doubleCalloc_dist (int_t)
 
void * duser_malloc_dist (int_t, int_t)
 
void duser_free_dist (int_t, int_t)
 
int_t zQuerySpace_dist (int_t, zLUstruct_t *, gridinfo_t *, SuperLUStat_t *, superlu_dist_mem_usage_t *)
 
void zClone_CompRowLoc_Matrix_dist (SuperMatrix *, SuperMatrix *)
 
void zCopy_CompRowLoc_Matrix_dist (SuperMatrix *, SuperMatrix *)
 
void zZero_CompRowLoc_Matrix_dist (SuperMatrix *)
 Sets all entries of a matrix to zero, A_{i,j}=0, for i,j=1,..,n. More...
 
void zScaleAddId_CompRowLoc_Matrix_dist (SuperMatrix *, doublecomplex)
 Scale and add I: scales a matrix and adds an identity. A_{i,j} = c * A_{i,j} + \delta_{i,j} for i,j=1,...,n and \delta_{i,j} is the Kronecker delta. More...
 
void zScaleAdd_CompRowLoc_Matrix_dist (SuperMatrix *, SuperMatrix *, doublecomplex)
 Scale and add: adds a scalar multiple of one matrix to another. A_{i,j} = c * A_{i,j} + B_{i,j}$ for i,j=1,...,n. More...
 
void zZeroLblocks (int, int, gridinfo_t *, zLUstruct_t *)
 Sets all entries of matrix L to zero. More...
 
void zZeroUblocks (int iam, int n, gridinfo_t *, zLUstruct_t *)
 Sets all entries of matrix U to zero. More...
 
void zfill_dist (doublecomplex *, int_t, doublecomplex)
 Fills a doublecomplex precision array with a given value. More...
 
void zinf_norm_error_dist (int_t, int_t, doublecomplex *, int_t, doublecomplex *, int_t, gridinfo_t *)
 Check the inf-norm of the error vector. More...
 
void pzinf_norm_error (int, int_t, int_t, doublecomplex[], int_t, doublecomplex[], int_t, MPI_Comm)
 Check the inf-norm of the error vector. More...
 
void zreadhb_dist (int, FILE *, int_t *, int_t *, int_t *, doublecomplex **, int_t **, int_t **)
 
void zreadtriple_dist (FILE *, int_t *, int_t *, int_t *, doublecomplex **, int_t **, int_t **)
 
void zreadtriple_noheader (FILE *, int_t *, int_t *, int_t *, doublecomplex **, int_t **, int_t **)
 
void zreadrb_dist (int, FILE *, int_t *, int_t *, int_t *, doublecomplex **, int_t **, int_t **)
 
void zreadMM_dist (FILE *, int_t *, int_t *, int_t *, doublecomplex **, int_t **, int_t **)
 
int zread_binary (FILE *, int_t *, int_t *, int_t *, doublecomplex **, int_t **, int_t **)
 
float zdist_psymbtonum (superlu_dist_options_t *, int_t, SuperMatrix *, zScalePermstruct_t *, Pslu_freeable_t *, zLUstruct_t *, gridinfo_t *)
 
void pzGetDiagU (int_t, zLUstruct_t *, gridinfo_t *, doublecomplex *)
 
int z_c2cpp_GetHWPM (SuperMatrix *, gridinfo_t *, zScalePermstruct_t *)
 
void zPrintLblocks (int, int_t, gridinfo_t *, Glu_persist_t *, zLocalLU_t *)
 Print the blocks in the factored matrix L. More...
 
void zPrintUblocks (int, int_t, gridinfo_t *, Glu_persist_t *, zLocalLU_t *)
 Print the blocks in the factored matrix U. More...
 
void zPrint_CompCol_Matrix_dist (SuperMatrix *)
 
void zPrint_Dense_Matrix_dist (SuperMatrix *)
 
int zPrint_CompRowLoc_Matrix_dist (SuperMatrix *)
 
int file_zPrint_CompRowLoc_Matrix_dist (FILE *fp, SuperMatrix *A)
 
void PrintDoublecomplex (char *, int_t, doublecomplex *)
 
int file_PrintDoublecomplex (FILE *fp, char *, int_t, doublecomplex *)
 
void zGenCOOLblocks (int, int_t, gridinfo_t *, Glu_persist_t *, zLocalLU_t *, int_t **, int_t **, doublecomplex **, int_t *, int_t *)
 
void zGenCSCLblocks (int, int_t, gridinfo_t *, Glu_persist_t *, zLocalLU_t *, doublecomplex **, int_t **, int_t **, int_t *, int_t *)
 
void zGenCSRLblocks (int, int_t, gridinfo_t *, Glu_persist_t *, zLocalLU_t *, doublecomplex **, int_t **, int_t **, int_t *, int_t *)
 
int zgemm_ (const char *, const char *, const int *, const int *, const int *, const doublecomplex *, const doublecomplex *, const int *, const doublecomplex *, const int *, const doublecomplex *, doublecomplex *, const int *)
 
int ztrsv_ (char *, char *, char *, int *, doublecomplex *, int *, doublecomplex *, int *)
 
int ztrsm_ (const char *, const char *, const char *, const char *, const int *, const int *, const doublecomplex *, const doublecomplex *, const int *, doublecomplex *, const int *)
 
void zgemv_ (const char *, const int *, const int *, const doublecomplex *, const doublecomplex *a, const int *, const doublecomplex *, const int *, const doublecomplex *, doublecomplex *, const int *)
 
void zgeru_ (const int *, const int *, const doublecomplex *, const doublecomplex *, const int *, const doublecomplex *, const int *, doublecomplex *, const int *)
 
int zscal_ (const int *n, const doublecomplex *alpha, doublecomplex *dx, const int *incx)
 
int zaxpy_ (const int *n, const doublecomplex *alpha, const doublecomplex *x, const int *incx, doublecomplex *y, const int *incy)
 
int superlu_zgemm (const char *transa, const char *transb, int m, int n, int k, doublecomplex alpha, doublecomplex *a, int lda, doublecomplex *b, int ldb, doublecomplex beta, doublecomplex *c, int ldc)
 
int superlu_ztrsm (const char *sideRL, const char *uplo, const char *transa, const char *diag, const int m, const int n, const doublecomplex alpha, const doublecomplex *a, const int lda, doublecomplex *b, const int ldb)
 
int superlu_zger (const int m, const int n, const doublecomplex alpha, const doublecomplex *x, const int incx, const doublecomplex *y, const int incy, doublecomplex *a, const int lda)
 
int superlu_zscal (const int n, const doublecomplex alpha, doublecomplex *x, const int incx)
 
int superlu_zaxpy (const int n, const doublecomplex alpha, const doublecomplex *x, const int incx, doublecomplex *y, const int incy)
 
int superlu_zgemv (const char *trans, const int m, const int n, const doublecomplex alpha, const doublecomplex *a, const int lda, const doublecomplex *x, const int incx, const doublecomplex beta, doublecomplex *y, const int incy)
 
int superlu_ztrsv (char *uplo, char *trans, char *diag, int n, doublecomplex *a, int lda, doublecomplex *x, int incx)
 
int zcreate_matrix3d (SuperMatrix *A, int nrhs, doublecomplex **rhs, int *ldb, doublecomplex **x, int *ldx, FILE *fp, gridinfo3d_t *grid3d)
 
int zcreate_matrix_postfix3d (SuperMatrix *A, int nrhs, doublecomplex **rhs, int *ldb, doublecomplex **x, int *ldx, FILE *fp, char *postfix, gridinfo3d_t *grid3d)
 
void zGatherNRformat_loc3d (fact_t Fact, NRformat_loc *A, doublecomplex *B, int ldb, int nrhs, gridinfo3d_t *grid3d, NRformat_loc3d **)
 
int zScatter_B3d (NRformat_loc3d *A3d, gridinfo3d_t *grid3d)
 
void pzgssvx3d (superlu_dist_options_t *, SuperMatrix *, zScalePermstruct_t *, doublecomplex B[], int ldb, int nrhs, gridinfo3d_t *, zLUstruct_t *, zSOLVEstruct_t *, double *berr, SuperLUStat_t *, int *info)
 
int_t pzgstrf3d (superlu_dist_options_t *, int m, int n, double anorm, ztrf3Dpartition_t *, SCT_t *, zLUstruct_t *, gridinfo3d_t *, SuperLUStat_t *, int *)
 
void zInit_HyP (HyP_t *HyP, zLocalLU_t *Llu, int_t mcb, int_t mrb)
 
void Free_HyP (HyP_t *HyP)
 
int updateDirtyBit (int_t k0, HyP_t *HyP, gridinfo_t *grid)
 
void zblock_gemm_scatter (int_t lb, int_t j, Ublock_info_t *Ublock_info, Remain_info_t *Remain_info, doublecomplex *L_mat, int ldl, doublecomplex *U_mat, int ldu, doublecomplex *bigV, int_t knsupc, int_t klst, int_t *lsub, int_t *usub, int_t ldt, int_t thread_id, int *indirect, int *indirect2, int_t **Lrowind_bc_ptr, doublecomplex **Lnzval_bc_ptr, int_t **Ufstnz_br_ptr, doublecomplex **Unzval_br_ptr, int_t *xsup, gridinfo_t *, SuperLUStat_t *)
 
int_t zblock_gemm_scatterTopLeft (int_t lb, int_t j, doublecomplex *bigV, int_t knsupc, int_t klst, int_t *lsub, int_t *usub, int_t ldt, int *indirect, int *indirect2, HyP_t *HyP, zLUstruct_t *, gridinfo_t *, SCT_t *SCT, SuperLUStat_t *)
 
int_t zblock_gemm_scatterTopRight (int_t lb, int_t j, doublecomplex *bigV, int_t knsupc, int_t klst, int_t *lsub, int_t *usub, int_t ldt, int *indirect, int *indirect2, HyP_t *HyP, zLUstruct_t *, gridinfo_t *, SCT_t *SCT, SuperLUStat_t *)
 
int_t zblock_gemm_scatterBottomLeft (int_t lb, int_t j, doublecomplex *bigV, int_t knsupc, int_t klst, int_t *lsub, int_t *usub, int_t ldt, int *indirect, int *indirect2, HyP_t *HyP, zLUstruct_t *, gridinfo_t *, SCT_t *SCT, SuperLUStat_t *)
 
int_t zblock_gemm_scatterBottomRight (int_t lb, int_t j, doublecomplex *bigV, int_t knsupc, int_t klst, int_t *lsub, int_t *usub, int_t ldt, int *indirect, int *indirect2, HyP_t *HyP, zLUstruct_t *, gridinfo_t *, SCT_t *SCT, SuperLUStat_t *)
 
void zgather_u (int_t num_u_blks, Ublock_info_t *Ublock_info, int_t *usub, doublecomplex *uval, doublecomplex *bigU, int_t ldu, int_t *xsup, int_t klst)
 
void zgather_l (int_t num_LBlk, int_t knsupc, Remain_info_t *L_info, doublecomplex *lval, int_t LD_lval, doublecomplex *L_buff)
 
void zRgather_L (int_t k, int_t *lsub, doublecomplex *lusup, gEtreeInfo_t *, Glu_persist_t *, gridinfo_t *, HyP_t *, int_t *myIperm, int_t *iperm_c_supno)
 
void zRgather_U (int_t k, int_t jj0, int_t *usub, doublecomplex *uval, doublecomplex *bigU, gEtreeInfo_t *, Glu_persist_t *, gridinfo_t *, HyP_t *, int_t *myIperm, int_t *iperm_c_supno, int_t *perm_u)
 
ztrf3Dpartition_tzinitTrf3Dpartition (int_t nsupers, superlu_dist_options_t *options, zLUstruct_t *LUstruct, gridinfo3d_t *grid3d)
 
void zDestroy_trf3Dpartition (ztrf3Dpartition_t *trf3Dpartition, gridinfo3d_t *grid3d)
 
void z3D_printMemUse (ztrf3Dpartition_t *trf3Dpartition, zLUstruct_t *LUstruct, gridinfo3d_t *grid3d)
 
void zinit3DLUstructForest (int_t *myTreeIdxs, int_t *myZeroTrIdxs, sForest_t **sForests, zLUstruct_t *LUstruct, gridinfo3d_t *grid3d)
 
int_t zgatherAllFactoredLUFr (int_t *myZeroTrIdxs, sForest_t *sForests, zLUstruct_t *LUstruct, gridinfo3d_t *grid3d, SCT_t *SCT)
 
int_t zLpanelUpdate (int_t off0, int_t nsupc, doublecomplex *ublk_ptr, int_t ld_ujrow, doublecomplex *lusup, int_t nsupr, SCT_t *)
 
void Local_Zgstrf2 (superlu_dist_options_t *options, int_t k, double thresh, doublecomplex *BlockUFactor, Glu_persist_t *, gridinfo_t *, zLocalLU_t *, SuperLUStat_t *, int *info, SCT_t *)
 
int_t zTrs2_GatherU (int_t iukp, int_t rukp, int_t klst, int_t nsupc, int_t ldu, int_t *usub, doublecomplex *uval, doublecomplex *tempv)
 
int_t zTrs2_ScatterU (int_t iukp, int_t rukp, int_t klst, int_t nsupc, int_t ldu, int_t *usub, doublecomplex *uval, doublecomplex *tempv)
 
int_t zTrs2_GatherTrsmScatter (int_t klst, int_t iukp, int_t rukp, int_t *usub, doublecomplex *uval, doublecomplex *tempv, int_t knsupc, int nsupr, doublecomplex *lusup, Glu_persist_t *Glu_persist)
 
void pzgstrs2 (int_t m, int_t k0, int_t k, Glu_persist_t *Glu_persist, gridinfo_t *grid, zLocalLU_t *Llu, SuperLUStat_t *stat)
 
void pzgstrf2 (superlu_dist_options_t *, int_t nsupers, int_t k0, int_t k, double thresh, Glu_persist_t *, gridinfo_t *, zLocalLU_t *, MPI_Request *, int, SuperLUStat_t *, int *)
 
int_t zAllocLlu_3d (int_t nsupers, zLUstruct_t *LUstruct, gridinfo3d_t *grid3d)
 
int_t zp3dScatter (int_t n, zLUstruct_t *LUstruct, gridinfo3d_t *grid3d)
 
int_t zscatter3dLPanels (int_t nsupers, zLUstruct_t *LUstruct, gridinfo3d_t *grid3d)
 
int_t zscatter3dUPanels (int_t nsupers, zLUstruct_t *LUstruct, gridinfo3d_t *grid3d)
 
int_t zcollect3dLpanels (int_t layer, int_t nsupers, zLUstruct_t *LUstruct, gridinfo3d_t *grid3d)
 
int_t zcollect3dUpanels (int_t layer, int_t nsupers, zLUstruct_t *LUstruct, gridinfo3d_t *grid3d)
 
int_t zp3dCollect (int_t layer, int_t n, zLUstruct_t *LUstruct, gridinfo3d_t *grid3d)
 
int_t zzeroSetLU (int_t nnodes, int_t *nodeList, zLUstruct_t *, gridinfo3d_t *)
 
int zAllocGlu_3d (int_t n, int_t nsupers, zLUstruct_t *)
 
int zDeAllocLlu_3d (int_t n, zLUstruct_t *, gridinfo3d_t *)
 
int zDeAllocGlu_3d (zLUstruct_t *)
 
int_t zreduceAncestors3d (int_t sender, int_t receiver, int_t nnodes, int_t *nodeList, doublecomplex *Lval_buf, doublecomplex *Uval_buf, zLUstruct_t *LUstruct, gridinfo3d_t *grid3d, SCT_t *SCT)
 
int zreduceAllAncestors3d (int_t ilvl, int_t *myNodeCount, int_t **treePerm, zLUValSubBuf_t *LUvsb, zLUstruct_t *LUstruct, gridinfo3d_t *grid3d, SCT_t *SCT)
 
int_t zgatherFactoredLU (int_t sender, int_t receiver, int_t nnodes, int_t *nodeList, zLUValSubBuf_t *LUvsb, zLUstruct_t *LUstruct, gridinfo3d_t *grid3d, SCT_t *SCT)
 
int_t zgatherAllFactoredLU (ztrf3Dpartition_t *trf3Dpartition, zLUstruct_t *LUstruct, gridinfo3d_t *grid3d, SCT_t *SCT)
 
int_t zinit3DLUstruct (int_t *myTreeIdxs, int_t *myZeroTrIdxs, int_t *nodeCount, int_t **nodeList, zLUstruct_t *LUstruct, gridinfo3d_t *grid3d)
 
int_t zzSendLPanel (int_t k, int_t receiver, zLUstruct_t *LUstruct, gridinfo3d_t *grid3d, SCT_t *SCT)
 
int_t zzRecvLPanel (int_t k, int_t sender, doublecomplex alpha, doublecomplex beta, doublecomplex *Lval_buf, zLUstruct_t *LUstruct, gridinfo3d_t *grid3d, SCT_t *SCT)
 
int_t zzSendUPanel (int_t k, int_t receiver, zLUstruct_t *LUstruct, gridinfo3d_t *grid3d, SCT_t *SCT)
 
int_t zzRecvUPanel (int_t k, int_t sender, doublecomplex alpha, doublecomplex beta, doublecomplex *Uval_buf, zLUstruct_t *LUstruct, gridinfo3d_t *grid3d, SCT_t *SCT)
 
int_t zIBcast_LPanel (int_t k, int_t k0, int_t *lsub, doublecomplex *lusup, gridinfo_t *, int *msgcnt, MPI_Request *, int **ToSendR, int_t *xsup, int)
 
int_t zBcast_LPanel (int_t k, int_t k0, int_t *lsub, doublecomplex *lusup, gridinfo_t *, int *msgcnt, int **ToSendR, int_t *xsup, SCT_t *, int)
 
int_t zIBcast_UPanel (int_t k, int_t k0, int_t *usub, doublecomplex *uval, gridinfo_t *, int *msgcnt, MPI_Request *, int *ToSendD, int)
 
int_t zBcast_UPanel (int_t k, int_t k0, int_t *usub, doublecomplex *uval, gridinfo_t *, int *msgcnt, int *ToSendD, SCT_t *, int)
 
int_t zIrecv_LPanel (int_t k, int_t k0, int_t *Lsub_buf, doublecomplex *Lval_buf, gridinfo_t *, MPI_Request *, zLocalLU_t *, int)
 
int_t zIrecv_UPanel (int_t k, int_t k0, int_t *Usub_buf, doublecomplex *, zLocalLU_t *, gridinfo_t *, MPI_Request *, int)
 
int_t zWait_URecv (MPI_Request *, int *msgcnt, SCT_t *)
 
int_t zWait_LRecv (MPI_Request *, int *msgcnt, int *msgcntsU, gridinfo_t *, SCT_t *)
 
int_t zISend_UDiagBlock (int_t k0, doublecomplex *ublk_ptr, int_t size, MPI_Request *, gridinfo_t *, int)
 
int_t zRecv_UDiagBlock (int_t k0, doublecomplex *ublk_ptr, int_t size, int_t src, gridinfo_t *, SCT_t *, int)
 
int_t zPackLBlock (int_t k, doublecomplex *Dest, Glu_persist_t *, gridinfo_t *, zLocalLU_t *)
 
int_t zISend_LDiagBlock (int_t k0, doublecomplex *lblk_ptr, int_t size, MPI_Request *, gridinfo_t *, int)
 
int_t zIRecv_UDiagBlock (int_t k0, doublecomplex *ublk_ptr, int_t size, int_t src, MPI_Request *, gridinfo_t *, SCT_t *, int)
 
int_t zIRecv_LDiagBlock (int_t k0, doublecomplex *L_blk_ptr, int_t size, int_t src, MPI_Request *, gridinfo_t *, SCT_t *, int)
 
int_t zUDiagBlockRecvWait (int_t k, int_t *IrecvPlcd_D, int_t *factored_L, MPI_Request *, gridinfo_t *, zLUstruct_t *, SCT_t *)
 
int_t LDiagBlockRecvWait (int_t k, int_t *factored_U, MPI_Request *, gridinfo_t *)
 
int_t zDiagFactIBCast (int_t k, int_t k0, doublecomplex *BlockUFactor, doublecomplex *BlockLFactor, int_t *IrecvPlcd_D, MPI_Request *, MPI_Request *, MPI_Request *, MPI_Request *, gridinfo_t *, superlu_dist_options_t *, double thresh, zLUstruct_t *LUstruct, SuperLUStat_t *, int *info, SCT_t *, int tag_ub)
 
int_t zUPanelTrSolve (int_t k, doublecomplex *BlockLFactor, doublecomplex *bigV, int_t ldt, Ublock_info_t *, gridinfo_t *, zLUstruct_t *, SuperLUStat_t *, SCT_t *)
 
int_t zLPanelUpdate (int_t k, int_t *IrecvPlcd_D, int_t *factored_L, MPI_Request *, doublecomplex *BlockUFactor, gridinfo_t *, zLUstruct_t *, SCT_t *)
 
int_t zUPanelUpdate (int_t k, int_t *factored_U, MPI_Request *, doublecomplex *BlockLFactor, doublecomplex *bigV, int_t ldt, Ublock_info_t *, gridinfo_t *, zLUstruct_t *, SuperLUStat_t *, SCT_t *)
 
int_t zIBcastRecvLPanel (int_t k, int_t k0, int *msgcnt, MPI_Request *, MPI_Request *, int_t *Lsub_buf, doublecomplex *Lval_buf, int *factored, gridinfo_t *, zLUstruct_t *, SCT_t *, int tag_ub)
 
int_t zIBcastRecvUPanel (int_t k, int_t k0, int *msgcnt, MPI_Request *, MPI_Request *, int_t *Usub_buf, doublecomplex *Uval_buf, gridinfo_t *, zLUstruct_t *, SCT_t *, int tag_ub)
 
int_t zWaitL (int_t k, int *msgcnt, int *msgcntU, MPI_Request *, MPI_Request *, gridinfo_t *, zLUstruct_t *, SCT_t *)
 
int_t zWaitU (int_t k, int *msgcnt, MPI_Request *, MPI_Request *, gridinfo_t *, zLUstruct_t *, SCT_t *)
 
int_t zLPanelTrSolve (int_t k, int_t *factored_L, doublecomplex *BlockUFactor, gridinfo_t *, zLUstruct_t *)
 
int getNsupers (int, Glu_persist_t *)
 
int_t initPackLUInfo (int_t nsupers, packLUInfo_t *packLUInfo)
 
int freePackLUInfo (packLUInfo_t *packLUInfo)
 
int_t zSchurComplementSetup (int_t k, int *msgcnt, Ublock_info_t *, Remain_info_t *, uPanelInfo_t *, lPanelInfo_t *, int_t *, int_t *, int_t *, doublecomplex *bigU, int_t *Lsub_buf, doublecomplex *Lval_buf, int_t *Usub_buf, doublecomplex *Uval_buf, gridinfo_t *, zLUstruct_t *)
 
int_t zSchurComplementSetupGPU (int_t k, msgs_t *msgs, packLUInfo_t *, int_t *, int_t *, int_t *, gEtreeInfo_t *, factNodelists_t *, zscuBufs_t *, zLUValSubBuf_t *LUvsb, gridinfo_t *, zLUstruct_t *, HyP_t *)
 
doublecomplexzgetBigV (int_t, int_t)
 
doublecomplexzgetBigU (superlu_dist_options_t *, int_t, gridinfo_t *, zLUstruct_t *)
 
int_t zLluBufInit (zLUValSubBuf_t *, zLUstruct_t *)
 
int_t zinitScuBufs (superlu_dist_options_t *, int_t ldt, int_t num_threads, int_t nsupers, zscuBufs_t *, zLUstruct_t *, gridinfo_t *)
 
int zfreeScuBufs (zscuBufs_t *scuBufs)
 
int_t zsparseTreeFactor (int_t nnodes, int_t *perm_c_supno, treeTopoInfo_t *treeTopoInfo, commRequests_t *comReqs, zscuBufs_t *scuBufs, packLUInfo_t *packLUInfo, msgs_t *msgs, zLUValSubBuf_t *LUvsb, zdiagFactBufs_t *dFBuf, factStat_t *factStat, factNodelists_t *fNlists, superlu_dist_options_t *options, int_t *gIperm_c_supno, int_t ldt, zLUstruct_t *LUstruct, gridinfo3d_t *grid3d, SuperLUStat_t *stat, double thresh, SCT_t *SCT, int *info)
 
int_t zdenseTreeFactor (int_t nnnodes, int_t *perm_c_supno, commRequests_t *comReqs, zscuBufs_t *scuBufs, packLUInfo_t *packLUInfo, msgs_t *msgs, zLUValSubBuf_t *LUvsb, zdiagFactBufs_t *dFBuf, factStat_t *factStat, factNodelists_t *fNlists, superlu_dist_options_t *options, int_t *gIperm_c_supno, int_t ldt, zLUstruct_t *LUstruct, gridinfo3d_t *grid3d, SuperLUStat_t *stat, double thresh, SCT_t *SCT, int tag_ub, int *info)
 
int_t zsparseTreeFactor_ASYNC (sForest_t *sforest, commRequests_t **comReqss, zscuBufs_t *scuBufs, packLUInfo_t *packLUInfo, msgs_t **msgss, zLUValSubBuf_t **LUvsbs, zdiagFactBufs_t **dFBufs, factStat_t *factStat, factNodelists_t *fNlists, gEtreeInfo_t *gEtreeInfo, superlu_dist_options_t *options, int_t *gIperm_c_supno, int_t ldt, HyP_t *HyP, zLUstruct_t *LUstruct, gridinfo3d_t *grid3d, SuperLUStat_t *stat, double thresh, SCT_t *SCT, int tag_ub, int *info)
 
zLUValSubBuf_t ** zLluBufInitArr (int_t numLA, zLUstruct_t *LUstruct)
 
int zLluBufFreeArr (int_t numLA, zLUValSubBuf_t **LUvsbs)
 
zdiagFactBufs_t ** zinitDiagFactBufsArr (int_t mxLeafNode, int_t ldt, gridinfo_t *grid)
 
int zfreeDiagFactBufsArr (int_t mxLeafNode, zdiagFactBufs_t **dFBufs)
 
int_t zinitDiagFactBufs (int_t ldt, zdiagFactBufs_t *dFBuf)
 
int_t checkRecvUDiag (int_t k, commRequests_t *comReqs, gridinfo_t *grid, SCT_t *SCT)
 
int_t checkRecvLDiag (int_t k, commRequests_t *comReqs, gridinfo_t *, SCT_t *)
 

Detailed Description

Distributed SuperLU data types and function prototypes.

Copyright (c) 2003, The Regents of the University of California, through Lawrence Berkeley National Laboratory (subject to receipt of any required approvals from U.S. Dept. of Energy)

All rights reserved.

The source code is distributed under BSD license, see the file License.txt at the top-level directory.

-- Distributed SuperLU routine (version 7.0) --
Lawrence Berkeley National Lab, Univ. of California Berkeley,
Georgia Institute of Technology
November 1, 2007
April 5, 2015
September 18, 2018  version 6.0
February 8, 2019  version 6.1.1
May 10, 2019 version 7.0.0

Macro Definition Documentation

◆ MAX_LOOKAHEADS

#define MAX_LOOKAHEADS   50

Function Documentation

◆ checkRecvLDiag()

int_t checkRecvLDiag ( int_t  k,
commRequests_t comReqs,
gridinfo_t grid,
SCT_t SCT 
)
Here is the call graph for this function:

◆ checkRecvUDiag()

int_t checkRecvUDiag ( int_t  k,
commRequests_t comReqs,
gridinfo_t grid,
SCT_t SCT 
)
Here is the call graph for this function:

◆ doubleCalloc_dist()

double * doubleCalloc_dist ( int_t  n)
Here is the caller graph for this function:

◆ doublecomplexCalloc_dist()

doublecomplex * doublecomplexCalloc_dist ( int_t  n)

◆ doublecomplexMalloc_dist()

doublecomplex * doublecomplexMalloc_dist ( int_t  n)
Here is the caller graph for this function:

◆ doubleMalloc_dist()

double * doubleMalloc_dist ( int_t  n)

◆ duser_free_dist()

void duser_free_dist ( int_t  bytes,
int_t  which_end 
)

◆ duser_malloc_dist()

void * duser_malloc_dist ( int_t  bytes,
int_t  which_end 
)

◆ file_PrintDoublecomplex()

int file_PrintDoublecomplex ( FILE *  fp,
char *  name,
int_t  len,
doublecomplex x 
)

◆ file_zPrint_CompRowLoc_Matrix_dist()

int file_zPrint_CompRowLoc_Matrix_dist ( FILE *  fp,
SuperMatrix A 
)

◆ Free_HyP()

void Free_HyP ( HyP_t HyP)
Here is the caller graph for this function:

◆ freePackLUInfo()

int freePackLUInfo ( packLUInfo_t packLUInfo)

◆ getNsupers()

int getNsupers ( int  n,
Glu_persist_t Glu_persist 
)

◆ initPackLUInfo()

int_t initPackLUInfo ( int_t  nsupers,
packLUInfo_t packLUInfo 
)

◆ LDiagBlockRecvWait()

int_t LDiagBlockRecvWait ( int_t  k,
int_t factored_U,
MPI_Request *  L_diag_blk_recv_req,
gridinfo_t grid 
)

◆ Local_Zgstrf2()

void Local_Zgstrf2 ( superlu_dist_options_t options,
int_t  k,
double  thresh,
doublecomplex BlockUFactor,
Glu_persist_t ,
gridinfo_t ,
zLocalLU_t ,
SuperLUStat_t ,
int *  info,
SCT_t  
)

◆ PrintDoublecomplex()

void PrintDoublecomplex ( char *  name,
int_t  len,
doublecomplex x 
)
Here is the caller graph for this function:

◆ pxgstrs_finalize()

void pxgstrs_finalize ( pxgstrs_comm_t gstrs_comm)

◆ pzCompRow_loc_to_CompCol_global()

int pzCompRow_loc_to_CompCol_global ( int_t  need_value,
SuperMatrix A,
gridinfo_t grid,
SuperMatrix GA 
)

Gather A from the distributed compressed row format to global A in compressed column format.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ pzCompute_Diag_Inv()

void pzCompute_Diag_Inv ( int_t  n,
zLUstruct_t LUstruct,
gridinfo_t grid,
SuperLUStat_t stat,
int *  info 
)
Purpose
=======
  Compute the inverse of the diagonal blocks of the L and U
  triangular matrices.
Here is the caller graph for this function:

◆ pzdistribute()

float pzdistribute ( superlu_dist_options_t options,
int_t  n,
SuperMatrix A,
zScalePermstruct_t ScalePermstruct,
Glu_freeable_t Glu_freeable,
zLUstruct_t LUstruct,
gridinfo_t grid 
)
Here is the call graph for this function:

◆ pzGetDiagU()

void pzGetDiagU ( int_t  n,
zLUstruct_t LUstruct,
gridinfo_t grid,
doublecomplex diagU 
)
Purpose
=======

GetDiagU extracts the main diagonal of matrix U of the LU factorization.

Arguments
=========

n        (input) int
         Dimension of the matrix.

LUstruct (input) zLUstruct_t*
         The data structures to store the distributed L and U factors.
         see superlu_ddefs.h for its definition.

grid     (input) gridinfo_t*
         The 2D process mesh. It contains the MPI communicator, the number
         of process rows (NPROW), the number of process columns (NPCOL),
         and my process rank. It is an input argument to all the
         parallel routines.

diagU    (output) double*, dimension (n)
         The main diagonal of matrix U.
         On exit, it is available on all processes.


Note
====

The diagonal blocks of the L and U matrices are stored in the L
data structures, and are on the diagonal processes of the
2D process grid.

This routine is modified from gather_diag_to_all() in pzgstrs_Bglobal.c.
Here is the call graph for this function:

◆ pzgsequ()

void pzgsequ ( SuperMatrix A,
double *  r,
double *  c,
double *  rowcnd,
double *  colcnd,
double *  amax,
int_t info,
gridinfo_t grid 
)
    Purpose
    =======

    PZGSEQU computes row and column scalings intended to equilibrate an
    M-by-N sparse matrix A and reduce its condition number. R returns the row
    scale factors and C the column scale factors, chosen to try to make
    the largest element in each row and column of the matrix B with
    elements B(i,j)=R(i)*A(i,j)*C(j) have absolute value 1.

    R(i) and C(j) are restricted to be between SMLNUM = smallest safe
    number and BIGNUM = largest safe number.  Use of these scaling
    factors is not guaranteed to reduce the condition number of A but
    works well in practice.

    See supermatrix.h for the definition of 'SuperMatrix' structure.

    Arguments
    =========

    A       (input) SuperMatrix*
            The matrix of dimension (A->nrow, A->ncol) whose equilibration
            factors are to be computed. The type of A can be:
            Stype = SLU_NR_loc; Dtype = SLU_Z; Mtype = SLU_GE.

    R       (output) double*, size A->nrow
            If INFO = 0 or INFO > M, R contains the row scale factors
            for A.

    C       (output) double*, size A->ncol
            If INFO = 0,  C contains the column scale factors for A.

    ROWCND  (output) double*
            If INFO = 0 or INFO > M, ROWCND contains the ratio of the
            smallest R(i) to the largest R(i).  If ROWCND >= 0.1 and
            AMAX is neither too large nor too small, it is not worth
            scaling by R.

    COLCND  (output) double*
            If INFO = 0, COLCND contains the ratio of the smallest
            C(i) to the largest C(i).  If COLCND >= 0.1, it is not
            worth scaling by C.

    AMAX    (output) double*
            Absolute value of largest matrix element.  If AMAX is very
            close to overflow or very close to underflow, the matrix
            should be scaled.

    INFO    (output) int*
            = 0:  successful exit
            < 0:  if INFO = -i, the i-th argument had an illegal value
            > 0:  if INFO = i,  and i is
                  <= M:  the i-th row of A is exactly zero
                  >  M:  the (i-M)-th column of A is exactly zero

    GRID    (input) gridinof_t*
            The 2D process mesh.
    =====================================================================
Here is the call graph for this function:
Here is the caller graph for this function:

◆ pzgsmv()

void pzgsmv ( int_t  abs,
SuperMatrix A_internal,
gridinfo_t grid,
pzgsmv_comm_t gsmv_comm,
doublecomplex  x[],
doublecomplex  ax[] 
)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ pzgsmv_AXglobal()

int pzgsmv_AXglobal ( int_t  m,
int_t  update[],
doublecomplex  val[],
int_t  bindx[],
doublecomplex  X[],
doublecomplex  ax[] 
)
Performs sparse matrix-vector multiplication.
  • val/bindx stores the distributed MSR matrix A
  • X is global
  • ax product is distributed the same way as A
Here is the caller graph for this function:

◆ pzgsmv_AXglobal_abs()

int pzgsmv_AXglobal_abs ( int_t  m,
int_t  update[],
doublecomplex  val[],
int_t  bindx[],
doublecomplex  X[],
double  ax[] 
)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ pzgsmv_AXglobal_setup()

int pzgsmv_AXglobal_setup ( SuperMatrix ,
Glu_persist_t ,
gridinfo_t ,
int_t ,
int_t [],
doublecomplex [],
int_t [],
int_t  [] 
)

◆ pzgsmv_finalize()

void pzgsmv_finalize ( pzgsmv_comm_t gsmv_comm)
Here is the caller graph for this function:

◆ pzgsmv_init()

void pzgsmv_init ( SuperMatrix A,
int_t row_to_proc,
gridinfo_t grid,
pzgsmv_comm_t gsmv_comm 
)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ pzgsrfs()

void pzgsrfs ( superlu_dist_options_t ,
int_t  ,
SuperMatrix ,
double  ,
zLUstruct_t ,
zScalePermstruct_t ,
gridinfo_t ,
doublecomplex  [],
int_t  ,
doublecomplex  [],
int_t  ,
int  ,
zSOLVEstruct_t ,
double *  ,
SuperLUStat_t ,
int *   
)

◆ pzgsrfs_ABXglobal()

void pzgsrfs_ABXglobal ( superlu_dist_options_t options,
int_t  n,
SuperMatrix A,
double  anorm,
zLUstruct_t LUstruct,
gridinfo_t grid,
doublecomplex B,
int_t  ldb,
doublecomplex X,
int_t  ldx,
int  nrhs,
double *  berr,
SuperLUStat_t stat,
int *  info 
)
Purpose
=======

pzgsrfs_ABXglobal improves the computed solution to a system of linear
equations and provides error bounds and backward error estimates
for the solution.

Arguments
=========

n      (input) int (global)
       The order of the system of linear equations.

A      (input) SuperMatrix*
   The original matrix A, or the scaled A if equilibration was done.
       A is also permuted into the form Pc*Pr*A*Pc', where Pr and Pc
       are permutation matrices. The type of A can be:
       Stype = SLU_NCP; Dtype = SLU_Z; Mtype = SLU_GE.

       NOTE: Currently, A must reside in all processes when calling
             this routine.

anorm  (input) double
       The norm of the original matrix A, or the scaled A if
       equilibration was done.

LUstruct (input) zLUstruct_t*
       The distributed data structures storing L and U factors.
       The L and U factors are obtained from pzgstrf for
       the possibly scaled and permuted matrix A.
       See superlu_ddefs.h for the definition of 'zLUstruct_t'.

grid   (input) gridinfo_t*
       The 2D process mesh. It contains the MPI communicator, the number
       of process rows (NPROW), the number of process columns (NPCOL),
       and my process rank. It is an input argument to all the
       parallel routines.
       Grid can be initialized by subroutine SUPERLU_GRIDINIT.
       See superlu_ddefs.h for the definition of 'gridinfo_t'.

B      (input) doublecomplex* (global)
       The N-by-NRHS right-hand side matrix of the possibly equilibrated
       and row permuted system.

       NOTE: Currently, B must reside on all processes when calling
             this routine.

ldb    (input) int (global)
       Leading dimension of matrix B.

X      (input/output) doublecomplex* (global)
       On entry, the solution matrix X, as computed by PZGSTRS.
       On exit, the improved solution matrix X.
       If DiagScale = COL or BOTH, X should be premultiplied by diag(C)
       in order to obtain the solution to the original system.

       NOTE: Currently, X must reside on all processes when calling
             this routine.

ldx    (input) int (global)
       Leading dimension of matrix X.

nrhs   (input) int
       Number of right-hand sides.

berr   (output) double*, dimension (nrhs)
        The componentwise relative backward error of each solution
        vector X(j) (i.e., the smallest relative change in
        any element of A or B that makes X(j) an exact solution).

stat   (output) SuperLUStat_t*
       Record the statistics about the refinement steps.
       See util.h for the definition of SuperLUStat_t.

info   (output) int*
       = 0: successful exit
       < 0: if info = -i, the i-th argument had an illegal value

Internal Parameters
===================

ITMAX is the maximum number of steps of iterative refinement.
Here is the call graph for this function:

◆ pzgssvx()

void pzgssvx ( superlu_dist_options_t ,
SuperMatrix ,
zScalePermstruct_t ,
doublecomplex ,
int  ,
int  ,
gridinfo_t ,
zLUstruct_t ,
zSOLVEstruct_t ,
double *  ,
SuperLUStat_t ,
int *   
)

◆ pzgssvx3d()

void pzgssvx3d ( superlu_dist_options_t options,
SuperMatrix A,
zScalePermstruct_t ScalePermstruct,
doublecomplex  B[],
int  ldb,
int  nrhs,
gridinfo3d_t grid3d,
zLUstruct_t LUstruct,
zSOLVEstruct_t SOLVEstruct,
double *  berr,
SuperLUStat_t stat,
int *  info 
)
Here is the caller graph for this function:

◆ pzgssvx_ABglobal()

void pzgssvx_ABglobal ( superlu_dist_options_t ,
SuperMatrix ,
zScalePermstruct_t ,
doublecomplex ,
int  ,
int  ,
gridinfo_t ,
zLUstruct_t ,
double *  ,
SuperLUStat_t ,
int *   
)

◆ pzgstrf()

int_t pzgstrf ( superlu_dist_options_t options,
int  m,
int  n,
double  anorm,
zLUstruct_t LUstruct,
gridinfo_t grid,
SuperLUStat_t stat,
int *  info 
)
Purpose
=======

PZGSTRF performs the LU factorization in parallel.

Arguments
=========

options (input) superlu_dist_options_t*
        The structure defines the input parameters to control
        how the LU decomposition will be performed.
        The following field should be defined:
        o ReplaceTinyPivot (yes_no_t)
          Specifies whether to replace the tiny diagonals by
          sqrt(epsilon)*norm(A) during LU factorization.

m      (input) int
       Number of rows in the matrix.

n      (input) int
       Number of columns in the matrix.

anorm  (input) double
       The norm of the original matrix A, or the scaled A if
       equilibration was done.

LUstruct (input/output) zLUstruct_t*
        The data structures to store the distributed L and U factors.
        The following fields should be defined:

        o Glu_persist (input) Glu_persist_t*
          Global data structure (xsup, supno) replicated on all processes,
          describing the supernode partition in the factored matrices
          L and U:
        xsup[s] is the leading column of the s-th supernode,
            supno[i] is the supernode number to which column i belongs.

        o Llu (input/output) zLocalLU_t*
          The distributed data structures to store L and U factors.
          See superlu_zdefs.h for the definition of 'zLocalLU_t'.

grid   (input) gridinfo_t*
       The 2D process mesh. It contains the MPI communicator, the number
       of process rows (NPROW), the number of process columns (NPCOL),
       and my process rank. It is an input argument to all the
       parallel routines.
       Grid can be initialized by subroutine SUPERLU_GRIDINIT.
       See superlu_ddefs.h for the definition of 'gridinfo_t'.

stat   (output) SuperLUStat_t*
       Record the statistics on runtime and floating-point operation count.
       See util.h for the definition of 'SuperLUStat_t'.

info   (output) int*
       = 0: successful exit
       < 0: if info = -i, the i-th argument had an illegal value
       > 0: if info = i, U(i,i) is exactly zero. The factorization has
            been completed, but the factor U is exactly singular,
            and division by zero will occur if it is used to solve a
            system of equations.
Purpose
=======

PZGSTRF performs the LU factorization in parallel.

Arguments
=========

options (input) superlu_dist_options_t*
        The structure defines the input parameters to control
        how the LU decomposition will be performed.
        The following field should be defined:
        o ReplaceTinyPivot (yes_no_t)
          = NO:  do not modify pivots
          = YES: replace tiny pivots by sqrt(epsilon)*norm(A) during
                 LU factorization.

m      (input) int
       Number of rows in the matrix.

n      (input) int
       Number of columns in the matrix.

anorm  (input) double
       The norm of the original matrix A, or the scaled A if
       equilibration was done.

LUstruct (input/output) zLUstruct_t*
        The data structures to store the distributed L and U factors.
        The following fields should be defined:

        o Glu_persist (input) Glu_persist_t*
          Global data structure (xsup, supno) replicated on all processes,
          describing the supernode partition in the factored matrices
          L and U:
        xsup[s] is the leading column of the s-th supernode,
            supno[i] is the supernode number to which column i belongs.

        o Llu (input/output) zLocalLU_t*
          The distributed data structures to store L and U factors.
          See superlu_zdefs.h for the definition of 'zLocalLU_t'.

grid   (input) gridinfo_t*
       The 2D process mesh. It contains the MPI communicator, the number
       of process rows (NPROW), the number of process columns (NPCOL),
       and my process rank. It is an input argument to all the
       parallel routines.
       Grid can be initialized by subroutine SUPERLU_GRIDINIT.
       See superlu_ddefs.h for the definition of 'gridinfo_t'.

stat   (output) SuperLUStat_t*
       Record the statistics on runtime and floating-point operation count.
       See util.h for the definition of 'SuperLUStat_t'.

info   (output) int*
       = 0: successful exit
       < 0: if info = -i, the i-th argument had an illegal value
       > 0: if info = i, U(i,i) is exactly zero. The factorization has
            been completed, but the factor U is exactly singular,
            and division by zero will occur if it is used to solve a
            system of equations.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ pzgstrf2()

void pzgstrf2 ( superlu_dist_options_t ,
int_t  nsupers,
int_t  k0,
int_t  k,
double  thresh,
Glu_persist_t ,
gridinfo_t ,
zLocalLU_t ,
MPI_Request *  ,
int  ,
SuperLUStat_t ,
int *   
)

◆ pzgstrf2_trsm()

void pzgstrf2_trsm ( superlu_dist_options_t options,
int_t  k0,
int_t  k,
double  thresh,
Glu_persist_t Glu_persist,
gridinfo_t grid,
zLocalLU_t Llu,
MPI_Request *  U_diag_blk_send_req,
int  tag_ub,
SuperLUStat_t stat,
int *  info 
)
Purpose
=======
  Panel factorization -- block column k

  Factor diagonal and subdiagonal blocks and test for exact singularity.
  Only the column processes that own block column *k* participate
  in the work.

Arguments
=========
options (input) superlu_dist_options_t* (global)
        The structure defines the input parameters to control
        how the LU decomposition will be performed.

k0     (input) int (global)
       Counter of the next supernode to be factorized.

k      (input) int (global)
       The column number of the block column to be factorized.

thresh (input) double (global)
       The threshold value = s_eps * anorm.

Glu_persist (input) Glu_persist_t*
       Global data structures (xsup, supno) replicated on all processes.

grid   (input) gridinfo_t*
       The 2D process mesh.

Llu    (input/output) zLocalLU_t*
       Local data structures to store distributed L and U matrices.

U_diag_blk_send_req (input/output) MPI_Request*
       List of send requests to send down the diagonal block of U.

tag_ub (input) int
       Upper bound of MPI tag values.

stat   (output) SuperLUStat_t*
       Record the statistics about the factorization.
       See SuperLUStat_t structure defined in util.h.

info   (output) int*
       = 0: successful exit
       < 0: if info = -i, the i-th argument had an illegal value
       > 0: if info = i, U(i,i) is exactly zero. The factorization has
            been completed, but the factor U is exactly singular,
            and division by zero will occur if it is used to solve a
            system of equations.

ALWAYS SEND TO ALL OTHERS - TO FIX

ALWAYS SEND TO ALL OTHERS - TO FIX

Here is the call graph for this function:

◆ pzgstrf3d()

int_t pzgstrf3d ( superlu_dist_options_t options,
int  m,
int  n,
double  anorm,
ztrf3Dpartition_t trf3Dpartition,
SCT_t SCT,
zLUstruct_t LUstruct,
gridinfo3d_t grid3d,
SuperLUStat_t stat,
int *  info 
)
Here is the call graph for this function:

◆ pzgstrs()

void pzgstrs ( superlu_dist_options_t options,
int_t  n,
zLUstruct_t LUstruct,
zScalePermstruct_t ScalePermstruct,
gridinfo_t grid,
doublecomplex B,
int_t  m_loc,
int_t  fst_row,
int_t  ldb,
int  nrhs,
zSOLVEstruct_t SOLVEstruct,
SuperLUStat_t stat,
int *  info 
)
Purpose
=======

PZGSTRS solves a system of distributed linear equations
A*X = B with a general N-by-N matrix A using the LU factorization
computed by PZGSTRF.
If the equilibration, and row and column permutations were performed,
the LU factorization was performed for A1 where
    A1 = Pc*Pr*diag(R)*A*diag(C)*Pc^T = L*U
and the linear system solved is
    A1 * Y = Pc*Pr*B1, where B was overwritten by B1 = diag(R)*B, and
the permutation to B1 by Pc*Pr is applied internally in this routine.

Arguments
=========

options (input) superlu_dist_options_t*
        The structure defines the input parameters to control
        how the LU decomposition and triangular solve are performed.

n      (input) int (global)
       The order of the system of linear equations.

LUstruct (input) zLUstruct_t*
       The distributed data structures storing L and U factors.
       The L and U factors are obtained from PZGSTRF for
       the possibly scaled and permuted matrix A.
       See superlu_zdefs.h for the definition of 'zLUstruct_t'.
       A may be scaled and permuted into A1, so that
       A1 = Pc*Pr*diag(R)*A*diag(C)*Pc^T = L*U

grid   (input) gridinfo_t*
       The 2D process mesh. It contains the MPI communicator, the number
       of process rows (NPROW), the number of process columns (NPCOL),
       and my process rank. It is an input argument to all the
       parallel routines.
       Grid can be initialized by subroutine SUPERLU_GRIDINIT.
       See superlu_defs.h for the definition of 'gridinfo_t'.

B      (input/output) doublecomplex*
       On entry, the distributed right-hand side matrix of the possibly
       equilibrated system. That is, B may be overwritten by diag(R)*B.
       On exit, the distributed solution matrix Y of the possibly
       equilibrated system if info = 0, where Y = Pc*diag(C)^(-1)*X,
       and X is the solution of the original system.

m_loc  (input) int (local)
       The local row dimension of matrix B.

fst_row (input) int (global)
       The row number of B's first row in the global matrix.

ldb    (input) int (local)
       The leading dimension of matrix B.

nrhs   (input) int (global)
       Number of right-hand sides.

SOLVEstruct (input) zSOLVEstruct_t* (global)
       Contains the information for the communication during the
       solution phase.

stat   (output) SuperLUStat_t*
       Record the statistics about the triangular solves.
       See util.h for the definition of 'SuperLUStat_t'.

info   (output) int*
       = 0: successful exit
    < 0: if info = -i, the i-th argument had an illegal value
Here is the call graph for this function:

◆ pzgstrs2()

void pzgstrs2 ( int_t  m,
int_t  k0,
int_t  k,
Glu_persist_t Glu_persist,
gridinfo_t grid,
zLocalLU_t Llu,
SuperLUStat_t stat 
)

◆ pzgstrs2_omp()

void pzgstrs2_omp ( int_t  k0,
int_t  k,
Glu_persist_t Glu_persist,
gridinfo_t grid,
zLocalLU_t Llu,
Ublock_info_t Ublock_info,
SuperLUStat_t stat 
)

4/19/2019

4/19/2019

Here is the call graph for this function:
Here is the caller graph for this function:

◆ pzgstrs_Bglobal()

void pzgstrs_Bglobal ( superlu_dist_options_t options,
int_t  n,
zLUstruct_t LUstruct,
gridinfo_t grid,
doublecomplex B,
int_t  ldb,
int  nrhs,
SuperLUStat_t stat,
int *  info 
)
Purpose
=======

pzgstrs_Bglobal solves a system of distributed linear equations
A*X = B with a general N-by-N matrix A using the LU factorization
computed by pzgstrf.

Arguments
=========

options (input) superlu_dist_options_t*
        The structure defines the input parameters to control
        how the LU decomposition and triangular solve are performed.

n      (input) int (global)
       The order of the system of linear equations.

LUstruct (input) zLUstruct_t*
       The distributed data structures storing L and U factors.
       The L and U factors are obtained from pzgstrf for
       the possibly scaled and permuted matrix A.
       See superlu_ddefs.h for the definition of 'zLUstruct_t'.

grid   (input) gridinfo_t*
       The 2D process mesh. It contains the MPI communicator, the number
       of process rows (NPROW), the number of process columns (NPCOL),
       and my process rank. It is an input argument to all the
       parallel routines.
       Grid can be initialized by subroutine SUPERLU_GRIDINIT.
       See superlu_ddefs.h for the definition of 'gridinfo_t'.

B      (input/output) doublecomplex*
       On entry, the right-hand side matrix of the possibly equilibrated
       and row permuted system.
       On exit, the solution matrix of the possibly equilibrated
       and row permuted system if info = 0;

       NOTE: Currently, the N-by-NRHS  matrix B must reside on all
             processes when calling this routine.

ldb    (input) int (global)
       Leading dimension of matrix B.

nrhs   (input) int (global)
       Number of right-hand sides.

stat   (output) SuperLUStat_t*
       Record the statistics about the triangular solves.
       See util.h for the definition of 'SuperLUStat_t'.

info   (output) int*
       = 0: successful exit
    < 0: if info = -i, the i-th argument had an illegal value
Here is the call graph for this function:

◆ pzgstrs_init()

int_t pzgstrs_init ( int_t  n,
int_t  m_loc,
int_t  nrhs,
int_t  fst_row,
int_t  perm_r[],
int_t  perm_c[],
gridinfo_t grid,
Glu_persist_t Glu_persist,
zSOLVEstruct_t SOLVEstruct 
)

Destroy distributed L & U matrices. *‍/ void zDestroy_LU(int_t n, gridinfo_t *grid, zLUstruct_t *LUstruct) { int_t i, nb, nsupers; Glu_persist_t *Glu_persist = LUstruct->Glu_persist; zLocalLU_t *Llu = LUstruct->Llu;.

if ( DEBUGlevel>=1 ) int iam; MPI_Comm_rank( MPI_COMM_WORLD, &iam ); CHECK_MALLOC(iam, "Enter zDestroy_LU()"); #endif

zDestroy_Tree(n, grid, LUstruct);

nsupers = Glu_persist->supno[n-1] + 1;

nb = CEILING(nsupers, grid->npcol); // for (i = 0; i < nb; ++i) // if ( Llu->Lrowind_bc_ptr[i] ) { // SUPERLU_FREE (Llu->Lrowind_bc_ptr[i]); // SUPERLU_FREE (Llu->Lnzval_bc_ptr[i]); // } SUPERLU_FREE (Llu->Lrowind_bc_ptr); SUPERLU_FREE (Llu->Lrowind_bc_dat); SUPERLU_FREE (Llu->Lrowind_bc_offset);
SUPERLU_FREE (Llu->Lnzval_bc_ptr); SUPERLU_FREE (Llu->Lnzval_bc_dat); SUPERLU_FREE (Llu->Lnzval_bc_offset);

nb = CEILING(nsupers, grid->nprow); for (i = 0; i < nb; ++i) if ( Llu->Ufstnz_br_ptr[i] ) { SUPERLU_FREE (Llu->Ufstnz_br_ptr[i]); SUPERLU_FREE (Llu->Unzval_br_ptr[i]); } SUPERLU_FREE (Llu->Ufstnz_br_ptr); SUPERLU_FREE (Llu->Unzval_br_ptr);

/* The following can be freed after factorization. *‍/ SUPERLU_FREE(Llu->ToRecv); SUPERLU_FREE(Llu->ToSendD); SUPERLU_FREE(Llu->ToSendR[0]); SUPERLU_FREE(Llu->ToSendR);

/* The following can be freed only after iterative refinement. *‍/ SUPERLU_FREE(Llu->ilsum); SUPERLU_FREE(Llu->fmod); SUPERLU_FREE(Llu->fsendx_plist[0]); SUPERLU_FREE(Llu->fsendx_plist); SUPERLU_FREE(Llu->bmod); SUPERLU_FREE(Llu->bsendx_plist[0]); SUPERLU_FREE(Llu->bsendx_plist); SUPERLU_FREE(Llu->mod_bit);

// nb = CEILING(nsupers, grid->npcol); // for (i = 0; i < nb; ++i) // if ( Llu->Lindval_loc_bc_ptr[i]!=NULL) { // SUPERLU_FREE (Llu->Lindval_loc_bc_ptr[i]); // }
SUPERLU_FREE(Llu->Lindval_loc_bc_ptr); SUPERLU_FREE(Llu->Lindval_loc_bc_dat); SUPERLU_FREE(Llu->Lindval_loc_bc_offset);

nb = CEILING(nsupers, grid->npcol); for (i=0; i<nb; ++i) { // if(Llu->Linv_bc_ptr[i]!=NULL) { // SUPERLU_FREE(Llu->Linv_bc_ptr[i]); // }

if(Llu->Uinv_bc_ptr[i]!=NULL){ SUPERLU_FREE(Llu->Uinv_bc_ptr[i]); }
} SUPERLU_FREE(Llu->Linv_bc_ptr); SUPERLU_FREE(Llu->Linv_bc_dat); SUPERLU_FREE(Llu->Linv_bc_offset); SUPERLU_FREE(Llu->Uinv_bc_ptr); SUPERLU_FREE(Llu->Unnz);

nb = CEILING(nsupers, grid->npcol); for (i = 0; i < nb; ++i) if ( Llu->Urbs[i] ) { SUPERLU_FREE(Llu->Ucb_indptr[i]); SUPERLU_FREE(Llu->Ucb_valptr[i]); } SUPERLU_FREE(Llu->Ucb_indptr); SUPERLU_FREE(Llu->Ucb_valptr);
SUPERLU_FREE(Llu->Urbs);

SUPERLU_FREE(Glu_persist->xsup); SUPERLU_FREE(Glu_persist->supno);

#ifdef GPU_ACC checkGPU (gpuFree (Llu->d_xsup)); checkGPU (gpuFree (Llu->d_LRtree_ptr)); checkGPU (gpuFree (Llu->d_LBtree_ptr)); checkGPU (gpuFree (Llu->d_ilsum)); checkGPU (gpuFree (Llu->d_Lrowind_bc_dat)); checkGPU (gpuFree (Llu->d_Lrowind_bc_offset)); checkGPU (gpuFree (Llu->d_Lnzval_bc_dat)); checkGPU (gpuFree (Llu->d_Lnzval_bc_offset)); checkGPU (gpuFree (Llu->d_Linv_bc_dat)); checkGPU (gpuFree (Llu->d_Linv_bc_offset)); checkGPU (gpuFree (Llu->d_Lindval_loc_bc_dat)); checkGPU (gpuFree (Llu->d_Lindval_loc_bc_offset)); #endif

if ( DEBUGlevel>=1 ) CHECK_MALLOC(iam, "Exit zDestroy_LU()"); #endif }

/*!

   Purpose
   =======
     Set up the communication pattern for redistribution between B and X
     in the triangular solution.

   Arguments
   =========

   n      (input) int (global)
          The dimension of the linear system.

   m_loc  (input) int (local)
          The local row dimension of the distributed input matrix.

   nrhs   (input) int (global)
          Number of right-hand sides.

   fst_row (input) int (global)
          The row number of matrix B's first row in the global matrix.

   perm_r (input) int* (global)
          The row permutation vector.

   perm_c (input) int* (global)
          The column permutation vector.

   grid   (input) gridinfo_t*
          The 2D process mesh.
   
Purpose
=======
  Set up the communication pattern for redistribution between B and X
  in the triangular solution.

Arguments
=========

n      (input) int (global)
       The dimension of the linear system.

m_loc  (input) int (local)
       The local row dimension of the distributed input matrix.

nrhs   (input) int (global)
       Number of right-hand sides.

fst_row (input) int (global)
       The row number of matrix B's first row in the global matrix.

perm_r (input) int* (global)
       The row permutation vector.

perm_c (input) int* (global)
       The column permutation vector.

grid   (input) gridinfo_t*
       The 2D process mesh.
Here is the caller graph for this function:

◆ pzinf_norm_error()

void pzinf_norm_error ( int  iam,
int_t  n,
int_t  nrhs,
doublecomplex  x[],
int_t  ldx,
doublecomplex  xtrue[],
int_t  ldxtrue,
MPI_Comm  slucomm 
)

Check the inf-norm of the error vector.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ pzlangs()

double pzlangs ( char *  norm,
SuperMatrix A,
gridinfo_t grid 
)
    Purpose
    =======

    PZLANGS returns the value of the one norm, or the Frobenius norm, or
    the infinity norm, or the element of largest absolute value of a
    real matrix A.

    Description
    ===========

    PZLANGE returns the value

       PZLANGE = ( max(abs(A(i,j))), NORM = 'M' or 'm'
                 (
                 ( norm1(A),         NORM = '1', 'O' or 'o'
                 (
                 ( normI(A),         NORM = 'I' or 'i'
                 (
                 ( normF(A),         NORM = 'F', 'f', 'E' or 'e'

    where  norm1  denotes the  one norm of a matrix (maximum column sum),
    normI  denotes the  infinity norm  of a matrix  (maximum row sum) and
    normF  denotes the  Frobenius norm of a matrix (square root of sum of
    squares).  Note that  max(abs(A(i,j)))  is not a  matrix norm.

    Arguments
    =========

    NORM    (input) CHARACTER*1
            Specifies the value to be returned in DLANGE as described above.
    A       (input) SuperMatrix*
            The M by N sparse matrix A.
    GRID    (input) gridinof_t*
            The 2D process mesh.
   =====================================================================
Here is the call graph for this function:
Here is the caller graph for this function:

◆ pzlaqgs()

void pzlaqgs ( SuperMatrix A,
double *  r,
double *  c,
double  rowcnd,
double  colcnd,
double  amax,
char *  equed 
)
    Purpose
    =======

    PZLAQGS equilibrates a general sparse M by N matrix A using the row
    and column scaling factors in the vectors R and C.

    See supermatrix.h for the definition of 'SuperMatrix' structure.

    Arguments
    =========

    A       (input/output) SuperMatrix*
            On exit, the equilibrated matrix.  See EQUED for the form of
            the equilibrated matrix. The type of A can be:
        Stype = SLU_NR_loc; Dtype = SLU_Z; Mtype = SLU_GE.

    R       (input) double*, dimension (A->nrow)
            The row scale factors for A.

    C       (input) double*, dimension (A->ncol)
            The column scale factors for A.

    ROWCND  (input) double
            Ratio of the smallest R(i) to the largest R(i).

    COLCND  (input) double
            Ratio of the smallest C(i) to the largest C(i).

    AMAX    (input) double
            Absolute value of largest matrix entry.

    EQUED   (output) char*
            Specifies the form of equilibration that was done.
            = 'N':  No equilibration
            = 'R':  Row equilibration, i.e., A has been premultiplied by
                    diag(R).
            = 'C':  Column equilibration, i.e., A has been postmultiplied
                    by diag(C).
            = 'B':  Both row and column equilibration, i.e., A has been
                    replaced by diag(R) * A * diag(C).

    Internal Parameters
    ===================

    THRESH is a threshold value used to decide if row or column scaling
    should be done based on the ratio of the row or column scaling
    factors.  If ROWCND < THRESH, row scaling is done, and if
    COLCND < THRESH, column scaling is done.

    LARGE and SMALL are threshold values used to decide if row scaling
    should be done based on the absolute size of the largest matrix
    element.  If AMAX > LARGE or AMAX < SMALL, row scaling is done.

    =====================================================================
Here is the call graph for this function:
Here is the caller graph for this function:

◆ pzPermute_Dense_Matrix()

int pzPermute_Dense_Matrix ( int_t  fst_row,
int_t  m_loc,
int_t  row_to_proc[],
int_t  perm[],
doublecomplex  X[],
int  ldx,
doublecomplex  B[],
int  ldb,
int  nrhs,
gridinfo_t grid 
)

Permute the distributed dense matrix: B <= perm(X). perm[i] = j means the i-th row of X is in the j-th row of B.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ pzReDistribute_B_to_X()

int_t pzReDistribute_B_to_X ( doublecomplex B,
int_t  m_loc,
int  nrhs,
int_t  ldb,
int_t  fst_row,
int_t ilsum,
doublecomplex x,
zScalePermstruct_t ScalePermstruct,
Glu_persist_t Glu_persist,
gridinfo_t grid,
zSOLVEstruct_t SOLVEstruct 
)
Purpose
=======
  Re-distribute B on the diagonal processes of the 2D process mesh.

Note
====
  This routine can only be called after the routine pzgstrs_init(),
  in which the structures of the send and receive buffers are set up.

Arguments
=========

B      (input) doublecomplex*
       The distributed right-hand side matrix of the possibly
       equilibrated system.

m_loc  (input) int (local)
       The local row dimension of matrix B.

nrhs   (input) int (global)
       Number of right-hand sides.

ldb    (input) int (local)
       Leading dimension of matrix B.

fst_row (input) int (global)
       The row number of B's first row in the global matrix.

ilsum  (input) int* (global)
       Starting position of each supernode in a full array.

x      (output) doublecomplex*
       The solution vector. It is valid only on the diagonal processes.

ScalePermstruct (input) zScalePermstruct_t*
       The data structure to store the scaling and permutation vectors
       describing the transformations performed to the original matrix A.

grid   (input) gridinfo_t*
       The 2D process mesh.

SOLVEstruct (input) zSOLVEstruct_t*
       Contains the information for the communication during the
       solution phase.

Return value
============
Here is the call graph for this function:
Here is the caller graph for this function:

◆ scuStatUpdate()

int_t scuStatUpdate ( int_t  knsupc,
HyP_t HyP,
SCT_t SCT,
SuperLUStat_t stat 
)
Here is the caller graph for this function:

◆ sp_zgemm_dist()

int sp_zgemm_dist ( char *  transa,
int  n,
doublecomplex  alpha,
SuperMatrix A,
doublecomplex b,
int  ldb,
doublecomplex  beta,
doublecomplex c,
int  ldc 
)
  Purpose   
    =======   

    sp_z performs one of the matrix-matrix operations   

       C := alpha*op( A )*op( B ) + beta*C,   

    where  op( X ) is one of 

       op( X ) = X   or   op( X ) = X'   or   op( X ) = conjg( X' ),

    alpha and beta are scalars, and A, B and C are matrices, with op( A ) 
    an m by k matrix,  op( B )  a  k by n matrix and  C an m by n matrix. 


    Parameters   
    ==========   

    TRANSA - (input) char*
             On entry, TRANSA specifies the form of op( A ) to be used in 
             the matrix multiplication as follows:   
                TRANSA = 'N' or 'n',  op( A ) = A.   
                TRANSA = 'T' or 't',  op( A ) = A'.   
                TRANSA = 'C' or 'c',  op( A ) = conjg( A' ).   
             Unchanged on exit.   

    TRANSB - (input) char*
             On entry, TRANSB specifies the form of op( B ) to be used in 
             the matrix multiplication as follows:   
                TRANSB = 'N' or 'n',  op( B ) = B.   
                TRANSB = 'T' or 't',  op( B ) = B'.   
                TRANSB = 'C' or 'c',  op( B ) = conjg( B' ).   
             Unchanged on exit.   

    M      - (input) int   
             On entry,  M  specifies  the number of rows of the matrix 
         op( A ) and of the matrix C.  M must be at least zero. 
         Unchanged on exit.   

    N      - (input) int
             On entry,  N specifies the number of columns of the matrix 
         op( B ) and the number of columns of the matrix C. N must be 
         at least zero.
         Unchanged on exit.   

    K      - (input) int
             On entry, K specifies the number of columns of the matrix 
         op( A ) and the number of rows of the matrix op( B ). K must 
         be at least  zero.   
             Unchanged on exit.

    ALPHA  - (input) doublecomplex
             On entry, ALPHA specifies the scalar alpha.   

    A      - (input) SuperMatrix*
             Matrix A with a sparse format, of dimension (A->nrow, A->ncol).
             Currently, the type of A can be:
                 Stype = NC or NCP; Dtype = Z; Mtype = GE. 
             In the future, more general A can be handled.

    B      - DOUBLE COMPLEX PRECISION array of DIMENSION ( LDB, kb ), where kb is 
             n when TRANSB = 'N' or 'n',  and is  k otherwise.   
             Before entry with  TRANSB = 'N' or 'n',  the leading k by n 
             part of the array B must contain the matrix B, otherwise 
             the leading n by k part of the array B must contain the 
             matrix B.   
             Unchanged on exit.   

    LDB    - (input) int
             On entry, LDB specifies the first dimension of B as declared 
             in the calling (sub) program. LDB must be at least max( 1, n ).  
             Unchanged on exit.   

    BETA   - (input) doublecomplex
             On entry, BETA specifies the scalar beta. When BETA is   
             supplied as zero then C need not be set on input.   

    C      - DOUBLE COMPLEX PRECISION array of DIMENSION ( LDC, n ).   
             Before entry, the leading m by n part of the array C must 
             contain the matrix C,  except when beta is zero, in which 
             case C need not be set on entry.   
             On exit, the array C is overwritten by the m by n matrix 
         ( alpha*op( A )*B + beta*C ).   

    LDC    - (input) int
             On entry, LDC specifies the first dimension of C as declared 
             in the calling (sub)program. LDC must be at least max(1,m).   
             Unchanged on exit.   

    ==== Sparse Level 3 Blas routine.  
Here is the call graph for this function:

◆ sp_zgemv_dist()

int sp_zgemv_dist ( char *  trans,
doublecomplex  alpha,
SuperMatrix A,
doublecomplex x,
int  incx,
doublecomplex  beta,
doublecomplex y,
int  incy 
)

SpGEMV.

     Purpose
     =======

     sp_ztrsv_dist() solves one of the systems of equations   
         A*x = b,   or   A'*x = b,
     where b and x are n element vectors and A is a sparse unit , or   
     non-unit, upper or lower triangular matrix.   
     No test for singularity or near-singularity is included in this   
     routine. Such tests must be performed before calling this routine.   

     Parameters   
     ==========   

     uplo   - (input) char*
              On entry, uplo specifies whether the matrix is an upper or   
               lower triangular matrix as follows:   
                  uplo = 'U' or 'u'   A is an upper triangular matrix.   
                  uplo = 'L' or 'l'   A is a lower triangular matrix.   

     trans  - (input) char*
               On entry, trans specifies the equations to be solved as   
               follows:   
                  trans = 'N' or 'n'   A*x = b.   
                  trans = 'T' or 't'   A'*x = b.   
                  trans = 'C' or 'c'   A'*x = b.   

     diag   - (input) char*
               On entry, diag specifies whether or not A is unit   
               triangular as follows:   
                  diag = 'U' or 'u'   A is assumed to be unit triangular.   
                  diag = 'N' or 'n'   A is not assumed to be unit   
                                      triangular.   

     L       - (input) SuperMatrix*
           The factor L from the factorization Pr*A*Pc=L*U. Use
               compressed row subscripts storage for supernodes, i.e.,
               L has types: Stype = SLU_SC, Dtype = SLU_Z, Mtype = SLU_TRLU.

     U       - (input) SuperMatrix*
            The factor U from the factorization Pr*A*Pc=L*U.
            U has types: Stype = SLU_NC, Dtype = SLU_Z, Mtype = SLU_TRU.

     x       - (input/output) doublecomplex*
               Before entry, the incremented array X must contain the n   
               element right-hand side vector b. On exit, X is overwritten 
               with the solution vector x.

     info    - (output) int*
               If *info = -i, the i-th argument had an illegal value.
   
 */
int
sp_ztrsv_dist(char *uplo, char *trans, char *diag, SuperMatrix *L, 
          SuperMatrix *U, doublecomplex *x, int *info)
{




    SCformat *Lstore;
    NCformat *Ustore;
    doublecomplex   *Lval, *Uval;
    int incx = 1, incy = 1;
    doublecomplex alpha = {1.0, 0.0}, beta = {1.0, 0.0};
    doublecomplex comp_zero = {0.0, 0.0}, comp_temp;
    int nrow;
    int fsupc, nsupr, nsupc, luptr, istart, irow;
    int i, k, iptr, jcol;
    doublecomplex *work;
    flops_t solve_ops;
    /*extern SuperLUStat_t SuperLUStat;*/

    /* Test the input parameters */
    *info = 0;
    if ( strncmp(uplo,"L",1) != 0 && strncmp(uplo, "U",1) !=0 ) *info = -1;
    else if ( strncmp(trans, "N",1) !=0 && strncmp(trans, "T", 1) !=0 )
    *info = -2;
    else if ( strncmp(diag, "U", 1) !=0 && strncmp(diag, "N", 1) != 0 )
    *info = -3;
    else if ( L->nrow != L->ncol || L->nrow < 0 ) *info = -4;
    else if ( U->nrow != U->ncol || U->nrow < 0 ) *info = -5;
    if ( *info ) {
    i = -(*info);
    xerr_dist("sp_ztrsv_dist", &i);
    return 0;
    }

    Lstore = (SCformat *) L->Store;
    Lval = (doublecomplex *) Lstore->nzval;
    Ustore = (NCformat *) U->Store;
    Uval = (doublecomplex *) Ustore->nzval;
    solve_ops = 0;

    if ( !(work = doublecomplexCalloc_dist(L->nrow)) )
    ABORT("Malloc fails for work in sp_dtrsv_dist().");

    if ( strncmp(trans, "N", 1)==0 ) {  /* Form x := inv(A)*x. */

    if ( strncmp(uplo, "L", 1)==0 ) {
        /* Form x := inv(L)*x */
            if ( L->nrow == 0 ) return 0; /* Quick return */

        for (k = 0; k <= Lstore->nsuper; k++) {
        fsupc = SuperLU_L_FST_SUPC(k);
        istart = SuperLU_L_SUB_START(fsupc);
        nsupr = SuperLU_L_SUB_START(fsupc+1) - istart;
        nsupc = SuperLU_L_FST_SUPC(k+1) - fsupc;
        luptr = SuperLU_L_NZ_START(fsupc);
        nrow = nsupr - nsupc;
            solve_ops += 4 * nsupc * (nsupc - 1);
            solve_ops += 8 * nrow * nsupc;
        if ( nsupc == 1 ) {
            for (iptr=istart+1; iptr < SuperLU_L_SUB_START(fsupc+1); ++iptr) {
            irow = SuperLU_L_SUB(iptr);
            ++luptr;
            zz_mult(&comp_temp, &x[fsupc], &Lval[luptr]);
            z_sub(&x[irow], &x[irow], &comp_temp);
            }
        } else {


















            zlsolve (nsupr, nsupc, &Lval[luptr], &x[fsupc]);

            zmatvec (nsupr, nsupr-nsupc, nsupc, &Lval[luptr+nsupc],
            &x[fsupc], &work[0] );


            iptr = istart + nsupc;
            for (i = 0; i < nrow; ++i, ++iptr) {
            irow = SuperLU_L_SUB(iptr);
            z_sub(&x[irow], &x[irow], &work[i]); /* Scatter */
            work[i] = comp_zero;
            }
        }
        } /* for k ... */

    } else {
        /* Form x := inv(U)*x */

        if ( U->nrow == 0 ) return 0; /* Quick return */

        for (k = Lstore->nsuper; k >= 0; k--) {
            fsupc = SuperLU_L_FST_SUPC(k);
            nsupr = SuperLU_L_SUB_START(fsupc+1) - SuperLU_L_SUB_START(fsupc);
            nsupc = SuperLU_L_FST_SUPC(k+1) - fsupc;
            luptr = SuperLU_L_NZ_START(fsupc);
                solve_ops += 4 * nsupc * (nsupc + 1);

        if ( nsupc == 1 ) {
            slud_z_div(&x[fsupc], &x[fsupc], &Lval[luptr]);
            for (i = SuperLU_U_NZ_START(fsupc); i < SuperLU_U_NZ_START(fsupc+1); ++i) {
            irow = SuperLU_U_SUB(i);
            zz_mult(&comp_temp, &x[fsupc], &Uval[i]);
            z_sub(&x[irow], &x[irow], &comp_temp);
            }
        } else {











            zusolve ( nsupr, nsupc, &Lval[luptr], &x[fsupc] );


            for (jcol = fsupc; jcol < SuperLU_L_FST_SUPC(k+1); jcol++) {
                solve_ops += 8*(SuperLU_U_NZ_START(jcol+1) - SuperLU_U_NZ_START(jcol));
                for (i = SuperLU_U_NZ_START(jcol); i < SuperLU_U_NZ_START(jcol+1); 
                i++) {
                irow = SuperLU_U_SUB(i);
                zz_mult(&comp_temp, &x[jcol], &Uval[i]);
                z_sub(&x[irow], &x[irow], &comp_temp);
                }
                    }
        }
        } /* for k ... */

    }
    } else { /* Form x := inv(A')*x */

    if ( strncmp(uplo, "L", 1)==0 ) {
        /* Form x := inv(L')*x */
            if ( L->nrow == 0 ) return 0; /* Quick return */

        for (k = Lstore->nsuper; k >= 0; --k) {
            fsupc = SuperLU_L_FST_SUPC(k);
            istart = SuperLU_L_SUB_START(fsupc);
            nsupr = SuperLU_L_SUB_START(fsupc+1) - istart;
            nsupc = SuperLU_L_FST_SUPC(k+1) - fsupc;
            luptr = SuperLU_L_NZ_START(fsupc);

        solve_ops += 8 * (nsupr - nsupc) * nsupc;
        for (jcol = fsupc; jcol < SuperLU_L_FST_SUPC(k+1); jcol++) {
            iptr = istart + nsupc;
            for (i = SuperLU_L_NZ_START(jcol) + nsupc; 
                i < SuperLU_L_NZ_START(jcol+1); i++) {
            irow = SuperLU_L_SUB(iptr);
            zz_mult(&comp_temp, &x[irow], &Lval[i]);
                z_sub(&x[jcol], &x[jcol], &comp_temp);
            iptr++;
            }
        }

        if ( nsupc > 1 ) {
            solve_ops += 4 * nsupc * (nsupc - 1);













            ztrsv_("L", "T", "U", &nsupc, &Lval[luptr], &nsupr,
            &x[fsupc], &incx);

        }
        }
    } else {
        /* Form x := inv(U')*x */
        if ( U->nrow == 0 ) return 0; /* Quick return */

        for (k = 0; k <= Lstore->nsuper; k++) {
            fsupc = SuperLU_L_FST_SUPC(k);
            nsupr = SuperLU_L_SUB_START(fsupc+1) - SuperLU_L_SUB_START(fsupc);
            nsupc = SuperLU_L_FST_SUPC(k+1) - fsupc;
            luptr = SuperLU_L_NZ_START(fsupc);

        for (jcol = fsupc; jcol < SuperLU_L_FST_SUPC(k+1); jcol++) {
            solve_ops += 8*(SuperLU_U_NZ_START(jcol+1) - SuperLU_U_NZ_START(jcol));
            for (i = SuperLU_U_NZ_START(jcol); i < SuperLU_U_NZ_START(jcol+1); i++) {
            irow = SuperLU_U_SUB(i);
            zz_mult(&comp_temp, &x[irow], &Uval[i]);
                z_sub(&x[jcol], &x[jcol], &comp_temp);
            }
        }

        solve_ops += 4 * nsupc * (nsupc + 1);
        if ( nsupc == 1 ) {
            slud_z_div(&x[fsupc], &x[fsupc], &Lval[luptr]);
        } else {












            ztrsv_("U", "T", "N", &nsupc, &Lval[luptr], &nsupr,
                &x[fsupc], &incx);

        }
        } /* for k ... */
    }
    }

    /*SuperLUStat.ops[SOLVE] += solve_ops;*/
    SUPERLU_FREE(work);
    return 0;
} /* sp_ztrsv_dist */


/*!
  Purpose   
    =======   

    sp_zgemv_dist()  performs one of the matrix-vector operations   
       y := alpha*A*x + beta*y,   or   y := alpha*A'*x + beta*y,   
    where alpha and beta are scalars, x and y are vectors and A is a
    sparse A->nrow by A->ncol matrix.   

    Parameters   
    ==========   

    TRANS  - (input) char*
             On entry, TRANS specifies the operation to be performed as   
             follows:   
                TRANS = 'N' or 'n'   y := alpha*A*x + beta*y.   
                TRANS = 'T' or 't'   y := alpha*A'*x + beta*y.   
                TRANS = 'C' or 'c'   y := alpha*A'*x + beta*y.   

    ALPHA  - (input) double
             On entry, ALPHA specifies the scalar alpha.   

    A      - (input) SuperMatrix*
             Matrix A with a sparse format, of dimension (A->nrow, A->ncol).
             Currently, the type of A can be:
                 Stype = SLU_NC or SLU_NCP; Dtype = SLU_Z; Mtype = SLU_GE. 
             In the future, more general A can be handled.

    X      - (input) doublecomplex*, array of DIMENSION at least   
             ( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n'   
             and at least   
             ( 1 + ( m - 1 )*abs( INCX ) ) otherwise.   
             Before entry, the incremented array X must contain the   
             vector x.   

    INCX   - (input) int
             On entry, INCX specifies the increment for the elements of   
             X. INCX must not be zero.   

    BETA   - (input) doublecomplex
             On entry, BETA specifies the scalar beta. When BETA is   
             supplied as zero then Y need not be set on input.   

    Y      - (output) doublecomplex*,  array of DIMENSION at least   
             ( 1 + ( m - 1 )*abs( INCY ) ) when TRANS = 'N' or 'n'   
             and at least   
             ( 1 + ( n - 1 )*abs( INCY ) ) otherwise.   
             Before entry with BETA non-zero, the incremented array Y   
             must contain the vector y. On exit, Y is overwritten by the 
             updated vector y.

    INCY   - (input) int
             On entry, INCY specifies the increment for the elements of   
             Y. INCY must not be zero.   

    ==== Sparse Level 2 Blas routine.   
  Purpose   
    =======   

    sp_zgemv_dist()  performs one of the matrix-vector operations   
       y := alpha*A*x + beta*y,   or   y := alpha*A'*x + beta*y,   
    where alpha and beta are scalars, x and y are vectors and A is a
    sparse A->nrow by A->ncol matrix.   

    Parameters   
    ==========   

    TRANS  - (input) char*
             On entry, TRANS specifies the operation to be performed as   
             follows:   
                TRANS = 'N' or 'n'   y := alpha*A*x + beta*y.   
                TRANS = 'T' or 't'   y := alpha*A'*x + beta*y.   
                TRANS = 'C' or 'c'   y := alpha*A'*x + beta*y.   

    ALPHA  - (input) double
             On entry, ALPHA specifies the scalar alpha.   

    A      - (input) SuperMatrix*
             Matrix A with a sparse format, of dimension (A->nrow, A->ncol).
             Currently, the type of A can be:
                 Stype = SLU_NC or SLU_NCP; Dtype = SLU_Z; Mtype = SLU_GE. 
             In the future, more general A can be handled.

    X      - (input) doublecomplex*, array of DIMENSION at least   
             ( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n'   
             and at least   
             ( 1 + ( m - 1 )*abs( INCX ) ) otherwise.   
             Before entry, the incremented array X must contain the   
             vector x.   

    INCX   - (input) int
             On entry, INCX specifies the increment for the elements of   
             X. INCX must not be zero.   

    BETA   - (input) doublecomplex
             On entry, BETA specifies the scalar beta. When BETA is   
             supplied as zero then Y need not be set on input.   

    Y      - (output) doublecomplex*,  array of DIMENSION at least   
             ( 1 + ( m - 1 )*abs( INCY ) ) when TRANS = 'N' or 'n'   
             and at least   
             ( 1 + ( n - 1 )*abs( INCY ) ) otherwise.   
             Before entry with BETA non-zero, the incremented array Y   
             must contain the vector y. On exit, Y is overwritten by the 
             updated vector y.

    INCY   - (input) int
             On entry, INCY specifies the increment for the elements of   
             Y. INCY must not be zero.   

    ==== Sparse Level 2 Blas routine.   
Here is the call graph for this function:

◆ sp_ztrsv_dist()

int sp_ztrsv_dist ( char *  uplo,
char *  trans,
char *  diag,
SuperMatrix L,
SuperMatrix U,
doublecomplex x,
int *  info 
)
  Purpose
  =======

  sp_ztrsv_dist() solves one of the systems of equations   
      A*x = b,   or   A'*x = b,
  where b and x are n element vectors and A is a sparse unit , or   
  non-unit, upper or lower triangular matrix.   
  No test for singularity or near-singularity is included in this   
  routine. Such tests must be performed before calling this routine.   

  Parameters   
  ==========   

  uplo   - (input) char*
           On entry, uplo specifies whether the matrix is an upper or   
            lower triangular matrix as follows:   
               uplo = 'U' or 'u'   A is an upper triangular matrix.   
               uplo = 'L' or 'l'   A is a lower triangular matrix.   

  trans  - (input) char*
            On entry, trans specifies the equations to be solved as   
            follows:   
               trans = 'N' or 'n'   A*x = b.   
               trans = 'T' or 't'   A'*x = b.   
               trans = 'C' or 'c'   A'*x = b.   

  diag   - (input) char*
            On entry, diag specifies whether or not A is unit   
            triangular as follows:   
               diag = 'U' or 'u'   A is assumed to be unit triangular.   
               diag = 'N' or 'n'   A is not assumed to be unit   
                                   triangular.   

  L       - (input) SuperMatrix*
        The factor L from the factorization Pr*A*Pc=L*U. Use
            compressed row subscripts storage for supernodes, i.e.,
            L has types: Stype = SLU_SC, Dtype = SLU_Z, Mtype = SLU_TRLU.

  U       - (input) SuperMatrix*
         The factor U from the factorization Pr*A*Pc=L*U.
         U has types: Stype = SLU_NC, Dtype = SLU_Z, Mtype = SLU_TRU.

  x       - (input/output) doublecomplex*
            Before entry, the incremented array X must contain the n   
            element right-hand side vector b. On exit, X is overwritten 
            with the solution vector x.

  info    - (output) int*
            If *info = -i, the i-th argument had an illegal value.

◆ superlu_zaxpy()

int superlu_zaxpy ( const int  n,
const doublecomplex  alpha,
const doublecomplex x,
const int  incx,
doublecomplex y,
const int  incy 
)

◆ superlu_zgemm()

int superlu_zgemm ( const char *  transa,
const char *  transb,
int  m,
int  n,
int  k,
doublecomplex  alpha,
doublecomplex a,
int  lda,
doublecomplex b,
int  ldb,
doublecomplex  beta,
doublecomplex c,
int  ldc 
)

◆ superlu_zgemv()

int superlu_zgemv ( const char *  trans,
const int  m,
const int  n,
const doublecomplex  alpha,
const doublecomplex a,
const int  lda,
const doublecomplex x,
const int  incx,
const doublecomplex  beta,
doublecomplex y,
const int  incy 
)

◆ superlu_zger()

int superlu_zger ( const int  m,
const int  n,
const doublecomplex  alpha,
const doublecomplex x,
const int  incx,
const doublecomplex y,
const int  incy,
doublecomplex a,
const int  lda 
)

◆ superlu_zscal()

int superlu_zscal ( const int  n,
const doublecomplex  alpha,
doublecomplex x,
const int  incx 
)

◆ superlu_ztrsm()

int superlu_ztrsm ( const char *  sideRL,
const char *  uplo,
const char *  transa,
const char *  diag,
const int  m,
const int  n,
const doublecomplex  alpha,
const doublecomplex a,
const int  lda,
doublecomplex b,
const int  ldb 
)

◆ superlu_ztrsv()

int superlu_ztrsv ( char *  uplo,
char *  trans,
char *  diag,
int  n,
doublecomplex a,
int  lda,
doublecomplex x,
int  incx 
)

◆ updateDirtyBit()

int updateDirtyBit ( int_t  k0,
HyP_t HyP,
gridinfo_t grid 
)
Here is the caller graph for this function:

◆ z3D_printMemUse()

void z3D_printMemUse ( ztrf3Dpartition_t trf3Dpartition,
zLUstruct_t LUstruct,
gridinfo3d_t grid3d 
)
Here is the call graph for this function:

◆ z_c2cpp_GetHWPM()

int z_c2cpp_GetHWPM ( SuperMatrix A,
gridinfo_t grid,
zScalePermstruct_t ScalePermstruct 
)
Purpose
=======

Get heavy-weight perfect matching (HWPM).

Reference:


Arguments
=========

A      (input) SuperMatrix*
       The distributed input matrix A of dimension (A->nrow, A->ncol).
       The type of A can be: Stype = SLU_NR_loc; Dtype = SLU_D; Mtype = SLU_GE.

perm   (input) int_t*
       Permutation vector describing the transformation performed to
       the original matrix A.

ScalePermstruct (output) zScalePermstruct_t*
       ScalePermstruct->perm_r stores the permutation obtained from HWPM.


Return value
============
ScalePermstruct       = ScalePermstruct->perm_r stores the permutation

◆ zallocateA_dist()

void zallocateA_dist ( int_t  n,
int_t  nnz,
doublecomplex **  a,
int_t **  asub,
int_t **  xa 
)
Here is the call graph for this function:

◆ zAllocGlu_3d()

int zAllocGlu_3d ( int_t  n,
int_t  nsupers,
zLUstruct_t LUstruct 
)
Here is the call graph for this function:

◆ zAllocLlu_3d()

int_t zAllocLlu_3d ( int_t  nsupers,
zLUstruct_t LUstruct,
gridinfo3d_t grid3d 
)

◆ zaxpy_()

int zaxpy_ ( const int *  n,
const doublecomplex alpha,
const doublecomplex x,
const int *  incx,
doublecomplex y,
const int *  incy 
)

◆ zBcast_LPanel()

int_t zBcast_LPanel ( int_t  k,
int_t  k0,
int_t lsub,
doublecomplex lusup,
gridinfo_t ,
int *  msgcnt,
int **  ToSendR,
int_t xsup,
SCT_t ,
int   
)

◆ zBcast_UPanel()

int_t zBcast_UPanel ( int_t  k,
int_t  k0,
int_t usub,
doublecomplex uval,
gridinfo_t ,
int *  msgcnt,
int *  ToSendD,
SCT_t ,
int   
)

◆ zblock_gemm_scatter()

void zblock_gemm_scatter ( int_t  lb,
int_t  j,
Ublock_info_t Ublock_info,
Remain_info_t Remain_info,
doublecomplex L_mat,
int  ldl,
doublecomplex U_mat,
int  ldu,
doublecomplex bigV,
int_t  knsupc,
int_t  klst,
int_t lsub,
int_t usub,
int_t  ldt,
int_t  thread_id,
int *  indirect,
int *  indirect2,
int_t **  Lrowind_bc_ptr,
doublecomplex **  Lnzval_bc_ptr,
int_t **  Ufstnz_br_ptr,
doublecomplex **  Unzval_br_ptr,
int_t xsup,
gridinfo_t ,
SuperLUStat_t  
)

◆ zblock_gemm_scatterBottomLeft()

int_t zblock_gemm_scatterBottomLeft ( int_t  lb,
int_t  j,
doublecomplex bigV,
int_t  knsupc,
int_t  klst,
int_t lsub,
int_t usub,
int_t  ldt,
int *  indirect,
int *  indirect2,
HyP_t HyP,
zLUstruct_t ,
gridinfo_t ,
SCT_t SCT,
SuperLUStat_t  
)

◆ zblock_gemm_scatterBottomRight()

int_t zblock_gemm_scatterBottomRight ( int_t  lb,
int_t  j,
doublecomplex bigV,
int_t  knsupc,
int_t  klst,
int_t lsub,
int_t usub,
int_t  ldt,
int *  indirect,
int *  indirect2,
HyP_t HyP,
zLUstruct_t ,
gridinfo_t ,
SCT_t SCT,
SuperLUStat_t  
)

◆ zblock_gemm_scatterTopLeft()

int_t zblock_gemm_scatterTopLeft ( int_t  lb,
int_t  j,
doublecomplex bigV,
int_t  knsupc,
int_t  klst,
int_t lsub,
int_t usub,
int_t  ldt,
int *  indirect,
int *  indirect2,
HyP_t HyP,
zLUstruct_t ,
gridinfo_t ,
SCT_t SCT,
SuperLUStat_t  
)

◆ zblock_gemm_scatterTopRight()

int_t zblock_gemm_scatterTopRight ( int_t  lb,
int_t  j,
doublecomplex bigV,
int_t  knsupc,
int_t  klst,
int_t lsub,
int_t usub,
int_t  ldt,
int *  indirect,
int *  indirect2,
HyP_t HyP,
zLUstruct_t ,
gridinfo_t ,
SCT_t SCT,
SuperLUStat_t  
)

◆ zClone_CompRowLoc_Matrix_dist()

void zClone_CompRowLoc_Matrix_dist ( SuperMatrix ,
SuperMatrix  
)

◆ zcollect3dLpanels()

int_t zcollect3dLpanels ( int_t  layer,
int_t  nsupers,
zLUstruct_t LUstruct,
gridinfo3d_t grid3d 
)

◆ zcollect3dUpanels()

int_t zcollect3dUpanels ( int_t  layer,
int_t  nsupers,
zLUstruct_t LUstruct,
gridinfo3d_t grid3d 
)

◆ zCompRow_to_CompCol_dist()

void zCompRow_to_CompCol_dist ( int_t  ,
int_t  ,
int_t  ,
doublecomplex ,
int_t ,
int_t ,
doublecomplex **  ,
int_t **  ,
int_t **   
)

◆ zComputeLevelsets()

void zComputeLevelsets ( int  ,
int_t  ,
gridinfo_t ,
Glu_persist_t ,
zLocalLU_t ,
int_t  
)

◆ zCopy_CompCol_Matrix_dist()

void zCopy_CompCol_Matrix_dist ( SuperMatrix ,
SuperMatrix  
)

◆ zCopy_CompRowLoc_Matrix_dist()

void zCopy_CompRowLoc_Matrix_dist ( SuperMatrix A,
SuperMatrix B 
)

◆ zCopy_Dense_Matrix_dist()

void zCopy_Dense_Matrix_dist ( int_t  ,
int_t  ,
doublecomplex ,
int_t  ,
doublecomplex ,
int_t   
)

◆ zCreate_CompCol_Matrix_dist()

void zCreate_CompCol_Matrix_dist ( SuperMatrix ,
int_t  ,
int_t  ,
int_t  ,
doublecomplex ,
int_t ,
int_t ,
Stype_t  ,
Dtype_t  ,
Mtype_t   
)

◆ zCreate_CompRowLoc_Matrix_dist()

void zCreate_CompRowLoc_Matrix_dist ( SuperMatrix ,
int_t  ,
int_t  ,
int_t  ,
int_t  ,
int_t  ,
doublecomplex ,
int_t ,
int_t ,
Stype_t  ,
Dtype_t  ,
Mtype_t   
)

◆ zCreate_Dense_Matrix_dist()

void zCreate_Dense_Matrix_dist ( SuperMatrix ,
int_t  ,
int_t  ,
doublecomplex ,
int_t  ,
Stype_t  ,
Dtype_t  ,
Mtype_t   
)

◆ zcreate_matrix()

int zcreate_matrix ( SuperMatrix A,
int  nrhs,
doublecomplex **  rhs,
int *  ldb,
doublecomplex **  x,
int *  ldx,
FILE *  fp,
gridinfo_t grid 
)
Here is the call graph for this function:

◆ zcreate_matrix3d()

int zcreate_matrix3d ( SuperMatrix A,
int  nrhs,
doublecomplex **  rhs,
int *  ldb,
doublecomplex **  x,
int *  ldx,
FILE *  fp,
gridinfo3d_t grid3d 
)

◆ zcreate_matrix_dat()

int zcreate_matrix_dat ( SuperMatrix ,
int  ,
doublecomplex **  ,
int *  ,
doublecomplex **  ,
int *  ,
FILE *  ,
gridinfo_t  
)

◆ zcreate_matrix_postfix()

int zcreate_matrix_postfix ( SuperMatrix A,
int  nrhs,
doublecomplex **  rhs,
int *  ldb,
doublecomplex **  x,
int *  ldx,
FILE *  fp,
char *  postfix,
gridinfo_t grid 
)

◆ zcreate_matrix_postfix3d()

int zcreate_matrix_postfix3d ( SuperMatrix A,
int  nrhs,
doublecomplex **  rhs,
int *  ldb,
doublecomplex **  x,
int *  ldx,
FILE *  fp,
char *  postfix,
gridinfo3d_t grid3d 
)
Here is the call graph for this function:

◆ zcreate_matrix_rb()

int zcreate_matrix_rb ( SuperMatrix ,
int  ,
doublecomplex **  ,
int *  ,
doublecomplex **  ,
int *  ,
FILE *  ,
gridinfo_t  
)

◆ zCreate_SuperNode_Matrix_dist()

void zCreate_SuperNode_Matrix_dist ( SuperMatrix ,
int_t  ,
int_t  ,
int_t  ,
doublecomplex ,
int_t ,
int_t ,
int_t ,
int_t ,
int_t ,
Stype_t  ,
Dtype_t  ,
Mtype_t   
)

◆ zDeAllocGlu_3d()

int zDeAllocGlu_3d ( zLUstruct_t LUstruct)

◆ zDeAllocLlu_3d()

int zDeAllocLlu_3d ( int_t  n,
zLUstruct_t LUstruct,
gridinfo3d_t grid3d 
)

◆ zdenseTreeFactor()

int_t zdenseTreeFactor ( int_t  nnnodes,
int_t perm_c_supno,
commRequests_t comReqs,
zscuBufs_t scuBufs,
packLUInfo_t packLUInfo,
msgs_t msgs,
zLUValSubBuf_t LUvsb,
zdiagFactBufs_t dFBuf,
factStat_t factStat,
factNodelists_t fNlists,
superlu_dist_options_t options,
int_t gIperm_c_supno,
int_t  ldt,
zLUstruct_t LUstruct,
gridinfo3d_t grid3d,
SuperLUStat_t stat,
double  thresh,
SCT_t SCT,
int  tag_ub,
int *  info 
)

◆ zDestroy_A3d_gathered_on_2d()

void zDestroy_A3d_gathered_on_2d ( zSOLVEstruct_t SOLVEstruct,
gridinfo3d_t grid3d 
)
Here is the caller graph for this function:

◆ zDestroy_LU()

void zDestroy_LU ( int_t  n,
gridinfo_t grid,
zLUstruct_t LUstruct 
)

Destroy distributed L & U matrices.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ zDestroy_Tree()

void zDestroy_Tree ( int_t  n,
gridinfo_t grid,
zLUstruct_t LUstruct 
)

Destroy broadcast and reduction trees used in triangular solve.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ zDestroy_trf3Dpartition()

void zDestroy_trf3Dpartition ( ztrf3Dpartition_t trf3Dpartition,
gridinfo3d_t grid3d 
)

◆ zDiagFactIBCast()

int_t zDiagFactIBCast ( int_t  k,
int_t  k0,
doublecomplex BlockUFactor,
doublecomplex BlockLFactor,
int_t IrecvPlcd_D,
MPI_Request *  ,
MPI_Request *  ,
MPI_Request *  ,
MPI_Request *  ,
gridinfo_t ,
superlu_dist_options_t ,
double  thresh,
zLUstruct_t LUstruct,
SuperLUStat_t ,
int *  info,
SCT_t ,
int  tag_ub 
)

◆ zdist_psymbtonum()

float zdist_psymbtonum ( superlu_dist_options_t options,
int_t  n,
SuperMatrix A,
zScalePermstruct_t ScalePermstruct,
Pslu_freeable_t Pslu_freeable,
zLUstruct_t LUstruct,
gridinfo_t grid 
)
Purpose
=======
  Distribute the input matrix onto the 2D process mesh.

Arguments
=========

options (input) superlu_dist_options_t*
        The structure defines the input parameters to control
        how the LU decomposition and triangular solve are performed.
        options->Fact specifies whether or not the L and U structures
        will be re-used:
          = SamePattern_SameRowPerm: L and U structures are input, and
                                     unchanged on exit.
            This routine should not be called for this case, an error
            is generated.  Instead, pddistribute routine should be called.
          = DOFACT or SamePattern: L and U structures are computed and output.

n      (Input) int
       Dimension of the matrix.

A      (Input) SuperMatrix*
   The distributed input matrix A of dimension (A->nrow, A->ncol).
       A may be overwritten by diag(R)*A*diag(C)*Pc^T.
       The type of A can be: Stype = NR; Dtype = SLU_D; Mtype = GE.

ScalePermstruct (Input) zScalePermstruct_t*
       The data structure to store the scaling and permutation vectors
       describing the transformations performed to the original matrix A.

Glu_freeable (Input) *Glu_freeable_t
       The global structure describing the graph of L and U.

LUstruct (Input) zLUstruct_t*
       Data structures for L and U factors.

grid   (Input) gridinfo_t*
       The 2D process mesh.

Return value
============
  < 0, number of bytes allocated on return from the dist_symbLU
  > 0, number of bytes allocated for performing the distribution
      of the data, when out of memory.
       (an approximation).
Here is the call graph for this function:

◆ zdistribute()

float zdistribute ( superlu_dist_options_t options,
int_t  n,
SuperMatrix A,
Glu_freeable_t Glu_freeable,
zLUstruct_t LUstruct,
gridinfo_t grid 
)
Purpose
=======
  Distribute the matrix onto the 2D process mesh.

Arguments
=========

options (input) superlu_dist_options_t *
       options->Fact specifies whether or not the L and U structures will be re-used.
       = SamePattern_SameRowPerm: L and U structures are input, and
                                  unchanged on exit.
       = DOFACT or SamePattern: L and U structures are computed and output.

n      (input) int
       Dimension of the matrix.

A      (input) SuperMatrix*
   The original matrix A, permuted by columns, of dimension
       (A->nrow, A->ncol). The type of A can be:
       Stype = SLU_NCP; Dtype = SLU_Z; Mtype = SLU_GE.

LUstruct (input) zLUstruct_t*
       Data structures for L and U factors.

grid   (input) gridinfo_t*
       The 2D process mesh.

Return value
============
  > 0, working storage (in bytes) required to perform redistribution.
       (excluding LU factor size)
Here is the call graph for this function:

◆ zfill_dist()

void zfill_dist ( doublecomplex a,
int_t  alen,
doublecomplex  dval 
)

Fills a doublecomplex precision array with a given value.

◆ zFillRHS_dist()

void zFillRHS_dist ( char *  trans,
int_t  nrhs,
doublecomplex x,
int_t  ldx,
SuperMatrix A,
doublecomplex rhs,
int_t  ldb 
)

Let rhs[i] = sum of i-th row of A, so the solution vector is all 1's.

Here is the call graph for this function:

◆ zfreeDiagFactBufsArr()

int zfreeDiagFactBufsArr ( int_t  mxLeafNode,
zdiagFactBufs_t **  dFBufs 
)

◆ zfreeScuBufs()

int zfreeScuBufs ( zscuBufs_t scuBufs)

◆ zgather_l()

void zgather_l ( int_t  num_LBlk,
int_t  knsupc,
Remain_info_t L_info,
doublecomplex lval,
int_t  LD_lval,
doublecomplex L_buff 
)

◆ zgather_u()

void zgather_u ( int_t  num_u_blks,
Ublock_info_t Ublock_info,
int_t usub,
doublecomplex uval,
doublecomplex bigU,
int_t  ldu,
int_t xsup,
int_t  klst 
)

◆ zgatherAllFactoredLU()

int_t zgatherAllFactoredLU ( ztrf3Dpartition_t trf3Dpartition,
zLUstruct_t LUstruct,
gridinfo3d_t grid3d,
SCT_t SCT 
)

◆ zgatherAllFactoredLUFr()

int_t zgatherAllFactoredLUFr ( int_t myZeroTrIdxs,
sForest_t sForests,
zLUstruct_t LUstruct,
gridinfo3d_t grid3d,
SCT_t SCT 
)

◆ zgatherFactoredLU()

int_t zgatherFactoredLU ( int_t  sender,
int_t  receiver,
int_t  nnodes,
int_t nodeList,
zLUValSubBuf_t LUvsb,
zLUstruct_t LUstruct,
gridinfo3d_t grid3d,
SCT_t SCT 
)

◆ zGatherNRformat_loc3d()

void zGatherNRformat_loc3d ( fact_t  Fact,
NRformat_loc A,
doublecomplex B,
int  ldb,
int  nrhs,
gridinfo3d_t grid3d,
NRformat_loc3d **   
)

◆ zgemm_()

int zgemm_ ( const char *  ,
const char *  ,
const int *  ,
const int *  ,
const int *  ,
const doublecomplex ,
const doublecomplex ,
const int *  ,
const doublecomplex ,
const int *  ,
const doublecomplex ,
doublecomplex ,
const int *   
)

◆ zgemv_()

void zgemv_ ( const char *  ,
const int *  ,
const int *  ,
const doublecomplex ,
const doublecomplex a,
const int *  ,
const doublecomplex ,
const int *  ,
const doublecomplex ,
doublecomplex ,
const int *   
)

◆ zGenCOOLblocks()

void zGenCOOLblocks ( int  ,
int_t  ,
gridinfo_t ,
Glu_persist_t ,
zLocalLU_t ,
int_t **  ,
int_t **  ,
doublecomplex **  ,
int_t ,
int_t  
)

◆ zGenCSCLblocks()

void zGenCSCLblocks ( int  ,
int_t  ,
gridinfo_t ,
Glu_persist_t ,
zLocalLU_t ,
doublecomplex **  ,
int_t **  ,
int_t **  ,
int_t ,
int_t  
)

◆ zGenCSRLblocks()

void zGenCSRLblocks ( int  ,
int_t  ,
gridinfo_t ,
Glu_persist_t ,
zLocalLU_t ,
doublecomplex **  ,
int_t **  ,
int_t **  ,
int_t ,
int_t  
)

◆ zGenXtrue_dist()

void zGenXtrue_dist ( int_t  n,
int_t  nrhs,
doublecomplex x,
int_t  ldx 
)

◆ zgeru_()

void zgeru_ ( const int *  ,
const int *  ,
const doublecomplex ,
const doublecomplex ,
const int *  ,
const doublecomplex ,
const int *  ,
doublecomplex ,
const int *   
)

◆ zgetBigU()

doublecomplex * zgetBigU ( superlu_dist_options_t ,
int_t  ,
gridinfo_t ,
zLUstruct_t  
)

◆ zgetBigV()

doublecomplex * zgetBigV ( int_t  ,
int_t   
)

◆ zgsequ_dist()

void zgsequ_dist ( SuperMatrix A,
double *  r,
double *  c,
double *  rowcnd,
double *  colcnd,
double *  amax,
int_t info 
)
   
    Purpose   
    =======   

    ZGSEQU_DIST computes row and column scalings intended to equilibrate an   
    M-by-N sparse matrix A and reduce its condition number. R returns the row
    scale factors and C the column scale factors, chosen to try to make   
    the largest element in each row and column of the matrix B with   
    elements B(i,j)=R(i)*A(i,j)*C(j) have absolute value 1.   

    R(i) and C(j) are restricted to be between SMLNUM = smallest safe   
    number and BIGNUM = largest safe number.  Use of these scaling   
    factors is not guaranteed to reduce the condition number of A but   
    works well in practice.   

    See supermatrix.h for the definition of 'SuperMatrix' structure.

    Arguments   
    =========   

    A       (input) SuperMatrix*
            The matrix of dimension (A->nrow, A->ncol) whose equilibration
            factors are to be computed. The type of A can be:
            Stype = SLU_NC; Dtype = SLU_Z; Mtype = SLU_GE.

    R       (output) double*, size A->nrow
            If INFO = 0 or INFO > M, R contains the row scale factors   
            for A.

    C       (output) double*, size A->ncol
            If INFO = 0,  C contains the column scale factors for A.

    ROWCND  (output) double*
            If INFO = 0 or INFO > M, ROWCND contains the ratio of the   
            smallest R(i) to the largest R(i).  If ROWCND >= 0.1 and   
            AMAX is neither too large nor too small, it is not worth   
            scaling by R.

    COLCND  (output) double*
            If INFO = 0, COLCND contains the ratio of the smallest   
            C(i) to the largest C(i).  If COLCND >= 0.1, it is not   
            worth scaling by C.

    AMAX    (output) double*
            Absolute value of largest matrix element.  If AMAX is very   
            close to overflow or very close to underflow, the matrix   
            should be scaled.

    INFO    (output) int*
            = 0:  successful exit   
            < 0:  if INFO = -i, the i-th argument had an illegal value   
            > 0:  if INFO = i,  and i is   
                  <= M:  the i-th row of A is exactly zero   
                  >  M:  the (i-M)-th column of A is exactly zero   

    ===================================================================== 


Purpose   
  =======   

  ZGSEQU_DIST computes row and column scalings intended to equilibrate an   
  M-by-N sparse matrix A and reduce its condition number. R returns the row
  scale factors and C the column scale factors, chosen to try to make   
  the largest element in each row and column of the matrix B with   
  elements B(i,j)=R(i)*A(i,j)*C(j) have absolute value 1.   

  R(i) and C(j) are restricted to be between SMLNUM = smallest safe   
  number and BIGNUM = largest safe number.  Use of these scaling   
  factors is not guaranteed to reduce the condition number of A but   
  works well in practice.   

  See supermatrix.h for the definition of 'SuperMatrix' structure.

  Arguments   
  =========   

  A       (input) SuperMatrix*
          The matrix of dimension (A->nrow, A->ncol) whose equilibration
          factors are to be computed. The type of A can be:
          Stype = SLU_NC; Dtype = SLU_Z; Mtype = SLU_GE.

  R       (output) double*, size A->nrow
          If INFO = 0 or INFO > M, R contains the row scale factors   
          for A.

  C       (output) double*, size A->ncol
          If INFO = 0,  C contains the column scale factors for A.

  ROWCND  (output) double*
          If INFO = 0 or INFO > M, ROWCND contains the ratio of the   
          smallest R(i) to the largest R(i).  If ROWCND >= 0.1 and   
          AMAX is neither too large nor too small, it is not worth   
          scaling by R.

  COLCND  (output) double*
          If INFO = 0, COLCND contains the ratio of the smallest   
          C(i) to the largest C(i).  If COLCND >= 0.1, it is not   
          worth scaling by C.

  AMAX    (output) double*
          Absolute value of largest matrix element.  If AMAX is very   
          close to overflow or very close to underflow, the matrix   
          should be scaled.

  INFO    (output) int*
          = 0:  successful exit   
          < 0:  if INFO = -i, the i-th argument had an illegal value   
          > 0:  if INFO = i,  and i is   
                <= A->nrow:  the i-th row of A is exactly zero   
                >  A->ncol:  the (i-M)-th column of A is exactly zero   

  ===================================================================== 
Here is the call graph for this function:

◆ zIBcast_LPanel()

int_t zIBcast_LPanel ( int_t  k,
int_t  k0,
int_t lsub,
doublecomplex lusup,
gridinfo_t ,
int *  msgcnt,
MPI_Request *  ,
int **  ToSendR,
int_t xsup,
int   
)

◆ zIBcast_UPanel()

int_t zIBcast_UPanel ( int_t  k,
int_t  k0,
int_t usub,
doublecomplex uval,
gridinfo_t ,
int *  msgcnt,
MPI_Request *  ,
int *  ToSendD,
int   
)

◆ zIBcastRecvLPanel()

int_t zIBcastRecvLPanel ( int_t  k,
int_t  k0,
int *  msgcnt,
MPI_Request *  ,
MPI_Request *  ,
int_t Lsub_buf,
doublecomplex Lval_buf,
int *  factored,
gridinfo_t ,
zLUstruct_t ,
SCT_t ,
int  tag_ub 
)

◆ zIBcastRecvUPanel()

int_t zIBcastRecvUPanel ( int_t  k,
int_t  k0,
int *  msgcnt,
MPI_Request *  ,
MPI_Request *  ,
int_t Usub_buf,
doublecomplex Uval_buf,
gridinfo_t ,
zLUstruct_t ,
SCT_t ,
int  tag_ub 
)

◆ zinf_norm_error_dist()

void zinf_norm_error_dist ( int_t  n,
int_t  nrhs,
doublecomplex x,
int_t  ldx,
doublecomplex xtrue,
int_t  ldxtrue,
gridinfo_t grid 
)

Check the inf-norm of the error vector.

Here is the call graph for this function:

◆ zinit3DLUstruct()

int_t zinit3DLUstruct ( int_t myTreeIdxs,
int_t myZeroTrIdxs,
int_t nodeCount,
int_t **  nodeList,
zLUstruct_t LUstruct,
gridinfo3d_t grid3d 
)

◆ zinit3DLUstructForest()

void zinit3DLUstructForest ( int_t myTreeIdxs,
int_t myZeroTrIdxs,
sForest_t **  sForests,
zLUstruct_t LUstruct,
gridinfo3d_t grid3d 
)

◆ zInit_HyP()

void zInit_HyP ( HyP_t HyP,
zLocalLU_t Llu,
int_t  mcb,
int_t  mrb 
)

◆ zinitDiagFactBufs()

int_t zinitDiagFactBufs ( int_t  ldt,
zdiagFactBufs_t dFBuf 
)

◆ zinitDiagFactBufsArr()

zdiagFactBufs_t ** zinitDiagFactBufsArr ( int_t  mxLeafNode,
int_t  ldt,
gridinfo_t grid 
)

◆ zinitScuBufs()

int_t zinitScuBufs ( superlu_dist_options_t ,
int_t  ldt,
int_t  num_threads,
int_t  nsupers,
zscuBufs_t ,
zLUstruct_t ,
gridinfo_t  
)

◆ zinitTrf3Dpartition()

ztrf3Dpartition_t * zinitTrf3Dpartition ( int_t  nsupers,
superlu_dist_options_t options,
zLUstruct_t LUstruct,
gridinfo3d_t grid3d 
)

◆ zIRecv_LDiagBlock()

int_t zIRecv_LDiagBlock ( int_t  k0,
doublecomplex L_blk_ptr,
int_t  size,
int_t  src,
MPI_Request *  ,
gridinfo_t ,
SCT_t ,
int   
)

◆ zIrecv_LPanel()

int_t zIrecv_LPanel ( int_t  k,
int_t  k0,
int_t Lsub_buf,
doublecomplex Lval_buf,
gridinfo_t ,
MPI_Request *  ,
zLocalLU_t ,
int   
)

◆ zIRecv_UDiagBlock()

int_t zIRecv_UDiagBlock ( int_t  k0,
doublecomplex ublk_ptr,
int_t  size,
int_t  src,
MPI_Request *  ,
gridinfo_t ,
SCT_t ,
int   
)

◆ zIrecv_UPanel()

int_t zIrecv_UPanel ( int_t  k,
int_t  k0,
int_t Usub_buf,
doublecomplex ,
zLocalLU_t ,
gridinfo_t ,
MPI_Request *  ,
int   
)

◆ zISend_LDiagBlock()

int_t zISend_LDiagBlock ( int_t  k0,
doublecomplex lblk_ptr,
int_t  size,
MPI_Request *  ,
gridinfo_t ,
int   
)

◆ zISend_UDiagBlock()

int_t zISend_UDiagBlock ( int_t  k0,
doublecomplex ublk_ptr,
int_t  size,
MPI_Request *  ,
gridinfo_t ,
int   
)

◆ zlangs_dist()

double zlangs_dist ( char *  norm,
SuperMatrix A 
)
 
    Purpose   
    =======   

    ZLANGS_DIST returns the value of the one norm, or the Frobenius norm, or 
    the infinity norm, or the element of largest absolute value of a 
    real matrix A.   

    Description   
    ===========   

    ZLANGE returns the value   

       ZLANGE = ( max(abs(A(i,j))), NORM = 'M' or 'm'   
                (   
                ( norm1(A),         NORM = '1', 'O' or 'o'   
                (   
                ( normI(A),         NORM = 'I' or 'i'   
                (   
                ( normF(A),         NORM = 'F', 'f', 'E' or 'e'   

    where  norm1  denotes the  one norm of a matrix (maximum column sum), 
    normI  denotes the  infinity norm  of a matrix  (maximum row sum) and 
    normF  denotes the  Frobenius norm of a matrix (square root of sum of 
    squares).  Note that  max(abs(A(i,j)))  is not a  matrix norm.   

    Arguments   
    =========   

    NORM    (input) CHARACTER*1   
            Specifies the value to be returned in ZLANGE as described above.   
    A       (input) SuperMatrix*
            The M by N sparse matrix A. 

   ===================================================================== 
Here is the call graph for this function:

◆ zlaqgs_dist()

void zlaqgs_dist ( SuperMatrix A,
double *  r,
double *  c,
double  rowcnd,
double  colcnd,
double  amax,
char *  equed 
)
    Purpose   
    =======   

    ZLAQGS_DIST equilibrates a general sparse M by N matrix A using the row
    and column scaling factors in the vectors R and C.   

    See supermatrix.h for the definition of 'SuperMatrix' structure.

    Arguments   
    =========   

    A       (input/output) SuperMatrix*
            On exit, the equilibrated matrix.  See EQUED for the form of 
            the equilibrated matrix. The type of A can be:
        Stype = SLU_NC; Dtype = SLU_Z; Mtype = SLU_GE.

    R       (input) double*, dimension (A->nrow)
            The row scale factors for A.

    C       (input) double*, dimension (A->ncol)
            The column scale factors for A.

    ROWCND  (input) double
            Ratio of the smallest R(i) to the largest R(i).

    COLCND  (input) double
            Ratio of the smallest C(i) to the largest C(i).

    AMAX    (input) double
            Absolute value of largest matrix entry.

    EQUED   (output) char*
            Specifies the form of equilibration that was done.   
            = 'N':  No equilibration   
            = 'R':  Row equilibration, i.e., A has been premultiplied by  
                    diag(R).   
            = 'C':  Column equilibration, i.e., A has been postmultiplied  
                    by diag(C).   
            = 'B':  Both row and column equilibration, i.e., A has been
                    replaced by diag(R) * A * diag(C).   

    Internal Parameters   
    ===================   

    THRESH is a threshold value used to decide if row or column scaling   
    should be done based on the ratio of the row or column scaling   
    factors.  If ROWCND < THRESH, row scaling is done, and if   
    COLCND < THRESH, column scaling is done.   

    LARGE and SMALL are threshold values used to decide if row scaling   
    should be done based on the absolute size of the largest matrix   
    element.  If AMAX > LARGE or AMAX < SMALL, row scaling is done.   

    ===================================================================== 
  Purpose   
  =======   

  ZLAQGS_DIST equilibrates a general sparse M by N matrix A using the row and   
  scaling factors in the vectors R and C.   

  See supermatrix.h for the definition of 'SuperMatrix' structure.

  Arguments   
  =========   

  A       (input/output) SuperMatrix*
          On exit, the equilibrated matrix.  See EQUED for the form of 
          the equilibrated matrix. The type of A can be:
     Stype = NC; Dtype = SLU_Z; Mtype = GE.

  R       (input) double*, dimension (A->nrow)
          The row scale factors for A.

  C       (input) double*, dimension (A->ncol)
          The column scale factors for A.

  ROWCND  (input) double
          Ratio of the smallest R(i) to the largest R(i).

  COLCND  (input) double
          Ratio of the smallest C(i) to the largest C(i).

  AMAX    (input) double
          Absolute value of largest matrix entry.

  EQUED   (output) char*
          Specifies the form of equilibration that was done.   
          = 'N':  No equilibration   
          = 'R':  Row equilibration, i.e., A has been premultiplied by  
                  diag(R).   
          = 'C':  Column equilibration, i.e., A has been postmultiplied  
                  by diag(C).   
          = 'B':  Both row and column equilibration, i.e., A has been
                  replaced by diag(R) * A * diag(C).   

  Internal Parameters   
  ===================   

  THRESH is a threshold value used to decide if row or column scaling   
  should be done based on the ratio of the row or column scaling   
  factors.  If ROWCND < THRESH, row scaling is done, and if   
  COLCND < THRESH, column scaling is done.   

  LARGE and SMALL are threshold values used to decide if row scaling   
  should be done based on the absolute size of the largest matrix   
  element.  If AMAX > LARGE or AMAX < SMALL, row scaling is done.   

  ===================================================================== 
Here is the call graph for this function:

◆ zldperm_dist()

int zldperm_dist ( int  job,
int  n,
int_t  nnz,
int_t  colptr[],
int_t  adjncy[],
doublecomplex  nzval[],
int_t perm,
double  u[],
double  v[] 
)
Purpose
=======

  ZLDPERM finds a row permutation so that the matrix has large
  entries on the diagonal.

Arguments
=========

job    (input) int
       Control the action. Possible values for JOB are:
       = 1 : Compute a row permutation of the matrix so that the
             permuted matrix has as many entries on its diagonal as
             possible. The values on the diagonal are of arbitrary size.
             HSL subroutine MC21A/AD is used for this.
       = 2 : Compute a row permutation of the matrix so that the smallest
             value on the diagonal of the permuted matrix is maximized.
       = 3 : Compute a row permutation of the matrix so that the smallest
             value on the diagonal of the permuted matrix is maximized.
             The algorithm differs from the one used for JOB = 2 and may
             have quite a different performance.
       = 4 : Compute a row permutation of the matrix so that the sum
             of the diagonal entries of the permuted matrix is maximized.
       = 5 : Compute a row permutation of the matrix so that the product
             of the diagonal entries of the permuted matrix is maximized
             and vectors to scale the matrix so that the nonzero diagonal
             entries of the permuted matrix are one in absolute value and
             all the off-diagonal entries are less than or equal to one in
             absolute value.
       Restriction: 1 <= JOB <= 5.

n      (input) int
       The order of the matrix.

nnz    (input) int
       The number of nonzeros in the matrix.

adjncy (input) int*, of size nnz
       The adjacency structure of the matrix, which contains the row
       indices of the nonzeros.

colptr (input) int*, of size n+1
       The pointers to the beginning of each column in ADJNCY.

nzval  (input) doublecomplex*, of size nnz
       The nonzero values of the matrix. nzval[k] is the value of
       the entry corresponding to adjncy[k].
       It is not used if job = 1.

perm   (output) int*, of size n
       The permutation vector. perm[i] = j means row i in the
       original matrix is in row j of the permuted matrix.

u      (output) double*, of size n
       If job = 5, the natural logarithms of the row scaling factors.

v      (output) double*, of size n
       If job = 5, the natural logarithms of the column scaling factors.
       The scaled matrix B has entries b_ij = a_ij * exp(u_i + v_j).
Here is the call graph for this function:

◆ zLluBufFreeArr()

int zLluBufFreeArr ( int_t  numLA,
zLUValSubBuf_t **  LUvsbs 
)

◆ zLluBufInit()

int_t zLluBufInit ( zLUValSubBuf_t ,
zLUstruct_t  
)

◆ zLluBufInitArr()

zLUValSubBuf_t ** zLluBufInitArr ( int_t  numLA,
zLUstruct_t LUstruct 
)

◆ zLPanelTrSolve()

int_t zLPanelTrSolve ( int_t  k,
int_t factored_L,
doublecomplex BlockUFactor,
gridinfo_t ,
zLUstruct_t  
)

◆ zLPanelUpdate()

int_t zLPanelUpdate ( int_t  k,
int_t IrecvPlcd_D,
int_t factored_L,
MPI_Request *  ,
doublecomplex BlockUFactor,
gridinfo_t ,
zLUstruct_t ,
SCT_t  
)

◆ zLpanelUpdate()

int_t zLpanelUpdate ( int_t  off0,
int_t  nsupc,
doublecomplex ublk_ptr,
int_t  ld_ujrow,
doublecomplex lusup,
int_t  nsupr,
SCT_t  
)

◆ zlsum_bmod()

void zlsum_bmod ( doublecomplex lsum,
doublecomplex x,
doublecomplex xk,
int  nrhs,
int_t  k,
int *  bmod,
int_t Urbs,
Ucb_indptr_t **  Ucb_indptr,
int_t **  Ucb_valptr,
int_t xsup,
gridinfo_t grid,
zLocalLU_t Llu,
MPI_Request  send_req[],
SuperLUStat_t stat 
)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ zlsum_bmod_inv()

void zlsum_bmod_inv ( doublecomplex lsum,
doublecomplex x,
doublecomplex xk,
doublecomplex rtemp,
int  nrhs,
int_t  k,
int *  bmod,
int_t Urbs,
Ucb_indptr_t **  Ucb_indptr,
int_t **  Ucb_valptr,
int_t xsup,
gridinfo_t grid,
zLocalLU_t Llu,
SuperLUStat_t **  stat,
int_t root_send,
int_t nroot_send,
int_t  sizelsum,
int_t  sizertemp,
int  thread_id,
int  num_thread 
)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ zlsum_bmod_inv_master()

void zlsum_bmod_inv_master ( doublecomplex lsum,
doublecomplex x,
doublecomplex xk,
doublecomplex rtemp,
int  nrhs,
int_t  k,
int *  bmod,
int_t Urbs,
Ucb_indptr_t **  Ucb_indptr,
int_t **  Ucb_valptr,
int_t xsup,
gridinfo_t grid,
zLocalLU_t Llu,
SuperLUStat_t **  stat,
int_t  sizelsum,
int_t  sizertemp,
int  thread_id,
int  num_thread 
)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ zlsum_fmod()

void zlsum_fmod ( doublecomplex lsum,
doublecomplex x,
doublecomplex xk,
doublecomplex rtemp,
int  nrhs,
int  knsupc,
int_t  k,
int *  fmod,
int_t  nlb,
int_t  lptr,
int_t  luptr,
int_t xsup,
gridinfo_t grid,
zLocalLU_t Llu,
MPI_Request  send_req[],
SuperLUStat_t stat 
)
Purpose
=======
  Perform local block modifications: lsum[i] -= L_i,k * X[k].
Here is the call graph for this function:
Here is the caller graph for this function:

◆ zlsum_fmod_inv()

void zlsum_fmod_inv ( doublecomplex lsum,
doublecomplex x,
doublecomplex xk,
doublecomplex rtemp,
int  nrhs,
int_t  k,
int *  fmod,
int_t xsup,
gridinfo_t grid,
zLocalLU_t Llu,
SuperLUStat_t **  stat,
int_t leaf_send,
int_t nleaf_send,
int_t  sizelsum,
int_t  sizertemp,
int_t  recurlevel,
int_t  maxsuper,
int  thread_id,
int  num_thread 
)
Purpose
=======
  Perform local block modifications: lsum[i] -= L_i,k * X[k].
Here is the call graph for this function:
Here is the caller graph for this function:

◆ zlsum_fmod_inv_master()

void zlsum_fmod_inv_master ( doublecomplex lsum,
doublecomplex x,
doublecomplex xk,
doublecomplex rtemp,
int  nrhs,
int  knsupc,
int_t  k,
int *  fmod,
int_t  nlb,
int_t xsup,
gridinfo_t grid,
zLocalLU_t Llu,
SuperLUStat_t **  stat,
int_t  sizelsum,
int_t  sizertemp,
int_t  recurlevel,
int_t  maxsuper,
int  thread_id,
int  num_thread 
)
Purpose
=======
  Perform local block modifications: lsum[i] -= L_i,k * X[k].
Here is the call graph for this function:
Here is the caller graph for this function:

◆ zLUstructFree()

void zLUstructFree ( zLUstruct_t LUstruct)

Deallocate LUstruct.

Here is the caller graph for this function:

◆ zLUstructInit()

void zLUstructInit ( const  int_t,
zLUstruct_t LUstruct 
)

Allocate storage in LUstruct.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ zp3dCollect()

int_t zp3dCollect ( int_t  layer,
int_t  n,
zLUstruct_t LUstruct,
gridinfo3d_t grid3d 
)

◆ zp3dScatter()

int_t zp3dScatter ( int_t  n,
zLUstruct_t LUstruct,
gridinfo3d_t grid3d 
)

◆ zPackLBlock()

int_t zPackLBlock ( int_t  k,
doublecomplex Dest,
Glu_persist_t ,
gridinfo_t ,
zLocalLU_t  
)

◆ zPrint_CompCol_Matrix_dist()

void zPrint_CompCol_Matrix_dist ( SuperMatrix )

◆ zPrint_CompRowLoc_Matrix_dist()

int zPrint_CompRowLoc_Matrix_dist ( SuperMatrix )

◆ zPrint_Dense_Matrix_dist()

void zPrint_Dense_Matrix_dist ( SuperMatrix )

◆ zPrintLblocks()

void zPrintLblocks ( int  iam,
int_t  nsupers,
gridinfo_t grid,
Glu_persist_t Glu_persist,
zLocalLU_t Llu 
)

Print the blocks in the factored matrix L.

Here is the call graph for this function:

◆ zPrintUblocks()

void zPrintUblocks ( int  iam,
int_t  nsupers,
gridinfo_t grid,
Glu_persist_t Glu_persist,
zLocalLU_t Llu 
)

Print the blocks in the factored matrix U.

Here is the call graph for this function:

◆ zQuerySpace_dist()

int_t zQuerySpace_dist ( int_t  n,
zLUstruct_t LUstruct,
gridinfo_t grid,
SuperLUStat_t stat,
superlu_dist_mem_usage_t mem_usage 
)
mem_usage consists of the following fields:
  • for_lu (float) The amount of space used in bytes for the L\U data structures.
  • total (float) The amount of space needed in bytes to perform factorization.
  • expansions (int) Number of memory expansions during the LU factorization.

◆ zread_binary()

int zread_binary ( FILE *  fp,
int_t m,
int_t n,
int_t nnz,
doublecomplex **  nzval,
int_t **  rowind,
int_t **  colptr 
)
Here is the call graph for this function:

◆ zreadhb_dist()

void zreadhb_dist ( int  iam,
FILE *  fp,
int_t nrow,
int_t ncol,
int_t nonz,
doublecomplex **  nzval,
int_t **  rowind,
int_t **  colptr 
)
Purpose
=======

Read a DOUBLE COMPLEX PRECISION matrix stored in Harwell-Boeing format
as described below.

Line 1 (A72,A8)
    Col. 1 - 72   Title (TITLE)
 Col. 73 - 80  Key (KEY)

Line 2 (5I14)
    Col. 1 - 14   Total number of lines excluding header (TOTCRD)
    Col. 15 - 28  Number of lines for pointers (PTRCRD)
    Col. 29 - 42  Number of lines for row (or variable) indices (INDCRD)
    Col. 43 - 56  Number of lines for numerical values (VALCRD)
 Col. 57 - 70  Number of lines for right-hand sides (RHSCRD)
                   (including starting guesses and solution vectors
           if present)
                  (zero indicates no right-hand side data is present)

Line 3 (A3, 11X, 4I14)
    Col. 1 - 3    Matrix type (see below) (MXTYPE)
    Col. 15 - 28  Number of rows (or variables) (NROW)
    Col. 29 - 42  Number of columns (or elements) (NCOL)
 Col. 43 - 56  Number of row (or variable) indices (NNZERO)
               (equal to number of entries for assembled matrices)
    Col. 57 - 70  Number of elemental matrix entries (NELTVL)
               (zero in the case of assembled matrices)
Line 4 (2A16, 2A20)
    Col. 1 - 16   Format for pointers (PTRFMT)
 Col. 17 - 32  Format for row (or variable) indices (INDFMT)
 Col. 33 - 52  Format for numerical values of coefficient matrix (VALFMT)
    Col. 53 - 72 Format for numerical values of right-hand sides (RHSFMT)

Line 5 (A3, 11X, 2I14) Only present if there are right-hand sides present
    Col. 1        Right-hand side type:
              F for full storage or M for same format as matrix
    Col. 2        G if a starting vector(s) (Guess) is supplied. (RHSTYP)
    Col. 3        X if an exact solution vector(s) is supplied.
 Col. 15 - 28  Number of right-hand sides (NRHS)
 Col. 29 - 42  Number of row indices (NRHSIX)
                  (ignored in case of unassembled matrices)

The three character type field on line 3 describes the matrix type.
The following table lists the permitted values for each of the three
characters. As an example of the type field, RSA denotes that the matrix
is real, symmetric, and assembled.

First Character:
 R Real matrix
 C Complex matrix
 P Pattern only (no numerical values supplied)

Second Character:
 S Symmetric
 U Unsymmetric
 H Hermitian
 Z Skew symmetric
 R Rectangular

Third Character:
 A Assembled
 E Elemental matrices (unassembled)
Here is the call graph for this function:

◆ zreadMM_dist()

void zreadMM_dist ( FILE *  fp,
int_t m,
int_t n,
int_t nonz,
doublecomplex **  nzval,
int_t **  rowind,
int_t **  colptr 
)

brief

Output parameters
=================
  (nzval, rowind, colptr): (*rowind)[*] contains the row subscripts of
     nonzeros in columns of matrix A; (*nzval)[*] the numerical values;
 column i of A is given by (*nzval)[k], k = (*rowind)[i],...,
     (*rowind)[i+1]-1.
Here is the call graph for this function:

◆ zreadrb_dist()

void zreadrb_dist ( int  iam,
FILE *  fp,
int_t nrow,
int_t ncol,
int_t nonz,
doublecomplex **  nzval,
int_t **  rowind,
int_t **  colptr 
)
Here is the call graph for this function:

◆ zreadtriple_dist()

void zreadtriple_dist ( FILE *  fp,
int_t m,
int_t n,
int_t nonz,
doublecomplex **  nzval,
int_t **  rowind,
int_t **  colptr 
)

brief

Output parameters
=================
  (nzval, rowind, colptr): (*rowind)[*] contains the row subscripts of
     nonzeros in columns of matrix A; (*nzval)[*] the numerical values;
 column i of A is given by (*nzval)[k], k = (*rowind)[i],...,
     (*rowind)[i+1]-1.
Here is the call graph for this function:

◆ zreadtriple_noheader()

void zreadtriple_noheader ( FILE *  fp,
int_t m,
int_t n,
int_t nonz,
doublecomplex **  nzval,
int_t **  rowind,
int_t **  colptr 
)

brief

Output parameters
=================
  (nzval, rowind, colptr): (*rowind)[*] contains the row subscripts of
     nonzeros in columns of matrix A; (*nzval)[*] the numerical values;
 column i of A is given by (*nzval)[k], k = (*rowind)[i],...,
     (*rowind)[i+1]-1.
Here is the call graph for this function:

◆ zRecv_UDiagBlock()

int_t zRecv_UDiagBlock ( int_t  k0,
doublecomplex ublk_ptr,
int_t  size,
int_t  src,
gridinfo_t ,
SCT_t ,
int   
)

◆ zreduceAllAncestors3d()

int zreduceAllAncestors3d ( int_t  ilvl,
int_t myNodeCount,
int_t **  treePerm,
zLUValSubBuf_t LUvsb,
zLUstruct_t LUstruct,
gridinfo3d_t grid3d,
SCT_t SCT 
)

◆ zreduceAncestors3d()

int_t zreduceAncestors3d ( int_t  sender,
int_t  receiver,
int_t  nnodes,
int_t nodeList,
doublecomplex Lval_buf,
doublecomplex Uval_buf,
zLUstruct_t LUstruct,
gridinfo3d_t grid3d,
SCT_t SCT 
)

◆ zRgather_L()

void zRgather_L ( int_t  k,
int_t lsub,
doublecomplex lusup,
gEtreeInfo_t ,
Glu_persist_t ,
gridinfo_t ,
HyP_t ,
int_t myIperm,
int_t iperm_c_supno 
)

◆ zRgather_U()

void zRgather_U ( int_t  k,
int_t  jj0,
int_t usub,
doublecomplex uval,
doublecomplex bigU,
gEtreeInfo_t ,
Glu_persist_t ,
gridinfo_t ,
HyP_t ,
int_t myIperm,
int_t iperm_c_supno,
int_t perm_u 
)

◆ zscal_()

int zscal_ ( const int *  n,
const doublecomplex alpha,
doublecomplex dx,
const int *  incx 
)

◆ zScaleAdd_CompRowLoc_Matrix_dist()

void zScaleAdd_CompRowLoc_Matrix_dist ( SuperMatrix A,
SuperMatrix B,
doublecomplex  c 
)

Scale and add: adds a scalar multiple of one matrix to another. A_{i,j} = c * A_{i,j} + B_{i,j}$ for i,j=1,...,n.

◆ zScaleAddId_CompRowLoc_Matrix_dist()

void zScaleAddId_CompRowLoc_Matrix_dist ( SuperMatrix A,
doublecomplex  c 
)

Scale and add I: scales a matrix and adds an identity. A_{i,j} = c * A_{i,j} + \delta_{i,j} for i,j=1,...,n and \delta_{i,j} is the Kronecker delta.

Here is the call graph for this function:

◆ zScalePermstructFree()

void zScalePermstructFree ( zScalePermstruct_t ScalePermstruct)

Deallocate ScalePermstruct.

◆ zScalePermstructInit()

void zScalePermstructInit ( const  int_t,
const  int_t,
zScalePermstruct_t ScalePermstruct 
)

Allocate storage in ScalePermstruct.

Here is the call graph for this function:

◆ zscatter3dLPanels()

int_t zscatter3dLPanels ( int_t  nsupers,
zLUstruct_t LUstruct,
gridinfo3d_t grid3d 
)

◆ zscatter3dUPanels()

int_t zscatter3dUPanels ( int_t  nsupers,
zLUstruct_t LUstruct,
gridinfo3d_t grid3d 
)

◆ zScatter_B3d()

int zScatter_B3d ( NRformat_loc3d A3d,
gridinfo3d_t grid3d 
)

◆ zscatter_l()

void zscatter_l ( int  ib,
int  ljb,
int  nsupc,
int_t  iukp,
int_t xsup,
int  klst,
int  nbrow,
int_t  lptr,
int  temp_nbrow,
int_t usub,
int_t lsub,
doublecomplex tempv,
int *  indirect_thread,
int *  indirect2,
int_t **  Lrowind_bc_ptr,
doublecomplex **  Lnzval_bc_ptr,
gridinfo_t grid 
)

◆ zscatter_u()

void zscatter_u ( int  ib,
int  jb,
int  nsupc,
int_t  iukp,
int_t xsup,
int  klst,
int  nbrow,
int_t  lptr,
int  temp_nbrow,
int_t lsub,
int_t usub,
doublecomplex tempv,
int_t **  Ufstnz_br_ptr,
doublecomplex **  Unzval_br_ptr,
gridinfo_t grid 
)

◆ zSchurComplementSetup()

int_t zSchurComplementSetup ( int_t  k,
int *  msgcnt,
Ublock_info_t ,
Remain_info_t ,
uPanelInfo_t ,
lPanelInfo_t ,
int_t ,
int_t ,
int_t ,
doublecomplex bigU,
int_t Lsub_buf,
doublecomplex Lval_buf,
int_t Usub_buf,
doublecomplex Uval_buf,
gridinfo_t ,
zLUstruct_t  
)

◆ zSchurComplementSetupGPU()

int_t zSchurComplementSetupGPU ( int_t  k,
msgs_t msgs,
packLUInfo_t ,
int_t ,
int_t ,
int_t ,
gEtreeInfo_t ,
factNodelists_t ,
zscuBufs_t ,
zLUValSubBuf_t LUvsb,
gridinfo_t ,
zLUstruct_t ,
HyP_t  
)

◆ zSolveFinalize()

void zSolveFinalize ( superlu_dist_options_t options,
zSOLVEstruct_t SOLVEstruct 
)

Release the resources used for the solution phase.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ zSolveInit()

int zSolveInit ( superlu_dist_options_t options,
SuperMatrix A,
int_t  perm_r[],
int_t  perm_c[],
int_t  nrhs,
zLUstruct_t LUstruct,
gridinfo_t grid,
zSOLVEstruct_t SOLVEstruct 
)

Initialize the data structure for the solution phase.

Here is the call graph for this function:
Here is the caller graph for this function:

◆ zsparseTreeFactor()

int_t zsparseTreeFactor ( int_t  nnodes,
int_t perm_c_supno,
treeTopoInfo_t treeTopoInfo,
commRequests_t comReqs,
zscuBufs_t scuBufs,
packLUInfo_t packLUInfo,
msgs_t msgs,
zLUValSubBuf_t LUvsb,
zdiagFactBufs_t dFBuf,
factStat_t factStat,
factNodelists_t fNlists,
superlu_dist_options_t options,
int_t gIperm_c_supno,
int_t  ldt,
zLUstruct_t LUstruct,
gridinfo3d_t grid3d,
SuperLUStat_t stat,
double  thresh,
SCT_t SCT,
int *  info 
)

◆ zsparseTreeFactor_ASYNC()

int_t zsparseTreeFactor_ASYNC ( sForest_t sforest,
commRequests_t **  comReqss,
zscuBufs_t scuBufs,
packLUInfo_t packLUInfo,
msgs_t **  msgss,
zLUValSubBuf_t **  LUvsbs,
zdiagFactBufs_t **  dFBufs,
factStat_t factStat,
factNodelists_t fNlists,
gEtreeInfo_t gEtreeInfo,
superlu_dist_options_t options,
int_t gIperm_c_supno,
int_t  ldt,
HyP_t HyP,
zLUstruct_t LUstruct,
gridinfo3d_t grid3d,
SuperLUStat_t stat,
double  thresh,
SCT_t SCT,
int  tag_ub,
int *  info 
)

◆ zstatic_schedule()

int zstatic_schedule ( superlu_dist_options_t options,
int  m,
int  n,
zLUstruct_t LUstruct,
gridinfo_t grid,
SuperLUStat_t stat,
int_t perm_c_supno,
int_t iperm_c_supno,
int *  info 
)
Here is the call graph for this function:

◆ zTrs2_GatherTrsmScatter()

int_t zTrs2_GatherTrsmScatter ( int_t  klst,
int_t  iukp,
int_t  rukp,
int_t usub,
doublecomplex uval,
doublecomplex tempv,
int_t  knsupc,
int  nsupr,
doublecomplex lusup,
Glu_persist_t Glu_persist 
)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ zTrs2_GatherU()

int_t zTrs2_GatherU ( int_t  iukp,
int_t  rukp,
int_t  klst,
int_t  nsupc,
int_t  ldu,
int_t usub,
doublecomplex uval,
doublecomplex tempv 
)
Here is the caller graph for this function:

◆ zTrs2_ScatterU()

int_t zTrs2_ScatterU ( int_t  iukp,
int_t  rukp,
int_t  klst,
int_t  nsupc,
int_t  ldu,
int_t usub,
doublecomplex uval,
doublecomplex tempv 
)
Here is the caller graph for this function:

◆ ztrsm_()

int ztrsm_ ( const char *  ,
const char *  ,
const char *  ,
const char *  ,
const int *  ,
const int *  ,
const doublecomplex ,
const doublecomplex ,
const int *  ,
doublecomplex ,
const int *   
)

◆ ztrsv_()

int ztrsv_ ( char *  ,
char *  ,
char *  ,
int *  ,
doublecomplex ,
int *  ,
doublecomplex ,
int *   
)

◆ zUDiagBlockRecvWait()

int_t zUDiagBlockRecvWait ( int_t  k,
int_t IrecvPlcd_D,
int_t factored_L,
MPI_Request *  ,
gridinfo_t ,
zLUstruct_t ,
SCT_t  
)

◆ zUPanelTrSolve()

int_t zUPanelTrSolve ( int_t  k,
doublecomplex BlockLFactor,
doublecomplex bigV,
int_t  ldt,
Ublock_info_t ,
gridinfo_t ,
zLUstruct_t ,
SuperLUStat_t ,
SCT_t  
)

◆ zUPanelUpdate()

int_t zUPanelUpdate ( int_t  k,
int_t factored_U,
MPI_Request *  ,
doublecomplex BlockLFactor,
doublecomplex bigV,
int_t  ldt,
Ublock_info_t ,
gridinfo_t ,
zLUstruct_t ,
SuperLUStat_t ,
SCT_t  
)

◆ zWait_LRecv()

int_t zWait_LRecv ( MPI_Request *  ,
int *  msgcnt,
int *  msgcntsU,
gridinfo_t ,
SCT_t  
)

◆ zWait_URecv()

int_t zWait_URecv ( MPI_Request *  ,
int *  msgcnt,
SCT_t  
)

◆ zWaitL()

int_t zWaitL ( int_t  k,
int *  msgcnt,
int *  msgcntU,
MPI_Request *  ,
MPI_Request *  ,
gridinfo_t ,
zLUstruct_t ,
SCT_t  
)

◆ zWaitU()

int_t zWaitU ( int_t  k,
int *  msgcnt,
MPI_Request *  ,
MPI_Request *  ,
gridinfo_t ,
zLUstruct_t ,
SCT_t  
)

◆ zZero_CompRowLoc_Matrix_dist()

void zZero_CompRowLoc_Matrix_dist ( SuperMatrix A)

Sets all entries of a matrix to zero, A_{i,j}=0, for i,j=1,..,n.

Here is the call graph for this function:

◆ zZeroLblocks()

void zZeroLblocks ( int  iam,
int  n,
gridinfo_t grid,
zLUstruct_t LUstruct 
)

Sets all entries of matrix L to zero.

◆ zzeroSetLU()

int_t zzeroSetLU ( int_t  nnodes,
int_t nodeList,
zLUstruct_t ,
gridinfo3d_t  
)

◆ zZeroUblocks()

void zZeroUblocks ( int  iam,
int  n,
gridinfo_t grid,
zLUstruct_t LUstruct 
)

Sets all entries of matrix U to zero.

◆ zzRecvLPanel()

int_t zzRecvLPanel ( int_t  k,
int_t  sender,
doublecomplex  alpha,
doublecomplex  beta,
doublecomplex Lval_buf,
zLUstruct_t LUstruct,
gridinfo3d_t grid3d,
SCT_t SCT 
)

◆ zzRecvUPanel()

int_t zzRecvUPanel ( int_t  k,
int_t  sender,
doublecomplex  alpha,
doublecomplex  beta,
doublecomplex Uval_buf,
zLUstruct_t LUstruct,
gridinfo3d_t grid3d,
SCT_t SCT 
)

◆ zzSendLPanel()

int_t zzSendLPanel ( int_t  k,
int_t  receiver,
zLUstruct_t LUstruct,
gridinfo3d_t grid3d,
SCT_t SCT 
)

◆ zzSendUPanel()

int_t zzSendUPanel ( int_t  k,
int_t  receiver,
zLUstruct_t LUstruct,
gridinfo3d_t grid3d,
SCT_t SCT 
)