SuperLU Distributed 8.2.1
Distributed memory sparse direct solver
|
Distributed SuperLU data types and function prototypes. More...
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 |
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
#define MAX_LOOKAHEADS 50 |
int_t checkRecvLDiag | ( | int_t | k, |
commRequests_t * | comReqs, | ||
gridinfo_t * | grid, | ||
SCT_t * | SCT | ||
) |
int_t checkRecvUDiag | ( | int_t | k, |
commRequests_t * | comReqs, | ||
gridinfo_t * | grid, | ||
SCT_t * | SCT | ||
) |
double * doubleCalloc_dist | ( | int_t | n | ) |
doublecomplex * doublecomplexCalloc_dist | ( | int_t | n | ) |
doublecomplex * doublecomplexMalloc_dist | ( | int_t | n | ) |
double * doubleMalloc_dist | ( | int_t | n | ) |
int file_PrintDoublecomplex | ( | FILE * | fp, |
char * | name, | ||
int_t | len, | ||
doublecomplex * | x | ||
) |
int file_zPrint_CompRowLoc_Matrix_dist | ( | FILE * | fp, |
SuperMatrix * | A | ||
) |
void Free_HyP | ( | HyP_t * | HyP | ) |
int freePackLUInfo | ( | packLUInfo_t * | packLUInfo | ) |
int getNsupers | ( | int | n, |
Glu_persist_t * | Glu_persist | ||
) |
int_t initPackLUInfo | ( | int_t | nsupers, |
packLUInfo_t * | packLUInfo | ||
) |
int_t LDiagBlockRecvWait | ( | int_t | k, |
int_t * | factored_U, | ||
MPI_Request * | L_diag_blk_recv_req, | ||
gridinfo_t * | grid | ||
) |
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 * | |||
) |
void PrintDoublecomplex | ( | char * | name, |
int_t | len, | ||
doublecomplex * | x | ||
) |
void pxgstrs_finalize | ( | pxgstrs_comm_t * | gstrs_comm | ) |
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.
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.
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 | ||
) |
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.
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. =====================================================================
void pzgsmv | ( | int_t | abs, |
SuperMatrix * | A_internal, | ||
gridinfo_t * | grid, | ||
pzgsmv_comm_t * | gsmv_comm, | ||
doublecomplex | x[], | ||
doublecomplex | ax[] | ||
) |
int pzgsmv_AXglobal | ( | int_t | m, |
int_t | update[], | ||
doublecomplex | val[], | ||
int_t | bindx[], | ||
doublecomplex | X[], | ||
doublecomplex | ax[] | ||
) |
Performs sparse matrix-vector multiplication.
int pzgsmv_AXglobal_abs | ( | int_t | m, |
int_t | update[], | ||
doublecomplex | val[], | ||
int_t | bindx[], | ||
doublecomplex | X[], | ||
double | ax[] | ||
) |
int pzgsmv_AXglobal_setup | ( | SuperMatrix * | , |
Glu_persist_t * | , | ||
gridinfo_t * | , | ||
int_t * | , | ||
int_t * | [], | ||
doublecomplex * | [], | ||
int_t * | [], | ||
int_t | [] | ||
) |
void pzgsmv_finalize | ( | pzgsmv_comm_t * | gsmv_comm | ) |
void pzgsmv_init | ( | SuperMatrix * | A, |
int_t * | row_to_proc, | ||
gridinfo_t * | grid, | ||
pzgsmv_comm_t * | gsmv_comm | ||
) |
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 * | 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.
void pzgssvx | ( | superlu_dist_options_t * | , |
SuperMatrix * | , | ||
zScalePermstruct_t * | , | ||
doublecomplex * | , | ||
int | , | ||
int | , | ||
gridinfo_t * | , | ||
zLUstruct_t * | , | ||
zSOLVEstruct_t * | , | ||
double * | , | ||
SuperLUStat_t * | , | ||
int * | |||
) |
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 | ||
) |
void pzgssvx_ABglobal | ( | superlu_dist_options_t * | , |
SuperMatrix * | , | ||
zScalePermstruct_t * | , | ||
doublecomplex * | , | ||
int | , | ||
int | , | ||
gridinfo_t * | , | ||
zLUstruct_t * | , | ||
double * | , | ||
SuperLUStat_t * | , | ||
int * | |||
) |
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.
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 * | |||
) |
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
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 | ||
) |
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
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 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
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
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.
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.
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. =====================================================================
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. =====================================================================
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.
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 ============
int_t scuStatUpdate | ( | int_t | knsupc, |
HyP_t * | HyP, | ||
SCT_t * | SCT, | ||
SuperLUStat_t * | stat | ||
) |
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.
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.
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.
int superlu_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_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_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_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_ztrsv | ( | char * | uplo, |
char * | trans, | ||
char * | diag, | ||
int | n, | ||
doublecomplex * | a, | ||
int | lda, | ||
doublecomplex * | x, | ||
int | incx | ||
) |
int updateDirtyBit | ( | int_t | k0, |
HyP_t * | HyP, | ||
gridinfo_t * | grid | ||
) |
void z3D_printMemUse | ( | ztrf3Dpartition_t * | trf3Dpartition, |
zLUstruct_t * | LUstruct, | ||
gridinfo3d_t * | grid3d | ||
) |
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
void zallocateA_dist | ( | int_t | n, |
int_t | nnz, | ||
doublecomplex ** | a, | ||
int_t ** | asub, | ||
int_t ** | xa | ||
) |
int zAllocGlu_3d | ( | int_t | n, |
int_t | nsupers, | ||
zLUstruct_t * | LUstruct | ||
) |
int_t zAllocLlu_3d | ( | int_t | nsupers, |
zLUstruct_t * | LUstruct, | ||
gridinfo3d_t * | grid3d | ||
) |
int zaxpy_ | ( | const int * | n, |
const doublecomplex * | alpha, | ||
const doublecomplex * | x, | ||
const int * | incx, | ||
doublecomplex * | y, | ||
const int * | incy | ||
) |
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 zBcast_UPanel | ( | int_t | k, |
int_t | k0, | ||
int_t * | usub, | ||
doublecomplex * | uval, | ||
gridinfo_t * | , | ||
int * | msgcnt, | ||
int * | ToSendD, | ||
SCT_t * | , | ||
int | |||
) |
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_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 * | |||
) |
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 * | |||
) |
void zClone_CompRowLoc_Matrix_dist | ( | SuperMatrix * | , |
SuperMatrix * | |||
) |
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 | ||
) |
void zCompRow_to_CompCol_dist | ( | int_t | , |
int_t | , | ||
int_t | , | ||
doublecomplex * | , | ||
int_t * | , | ||
int_t * | , | ||
doublecomplex ** | , | ||
int_t ** | , | ||
int_t ** | |||
) |
void zComputeLevelsets | ( | int | , |
int_t | , | ||
gridinfo_t * | , | ||
Glu_persist_t * | , | ||
zLocalLU_t * | , | ||
int_t * | |||
) |
void zCopy_CompCol_Matrix_dist | ( | SuperMatrix * | , |
SuperMatrix * | |||
) |
void zCopy_CompRowLoc_Matrix_dist | ( | SuperMatrix * | A, |
SuperMatrix * | B | ||
) |
void zCopy_Dense_Matrix_dist | ( | int_t | , |
int_t | , | ||
doublecomplex * | , | ||
int_t | , | ||
doublecomplex * | , | ||
int_t | |||
) |
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 zCreate_Dense_Matrix_dist | ( | SuperMatrix * | , |
int_t | , | ||
int_t | , | ||
doublecomplex * | , | ||
int_t | , | ||
Stype_t | , | ||
Dtype_t | , | ||
Mtype_t | |||
) |
int zcreate_matrix | ( | SuperMatrix * | A, |
int | nrhs, | ||
doublecomplex ** | rhs, | ||
int * | ldb, | ||
doublecomplex ** | x, | ||
int * | ldx, | ||
FILE * | fp, | ||
gridinfo_t * | grid | ||
) |
int zcreate_matrix3d | ( | SuperMatrix * | A, |
int | nrhs, | ||
doublecomplex ** | rhs, | ||
int * | ldb, | ||
doublecomplex ** | x, | ||
int * | ldx, | ||
FILE * | fp, | ||
gridinfo3d_t * | grid3d | ||
) |
int zcreate_matrix_dat | ( | SuperMatrix * | , |
int | , | ||
doublecomplex ** | , | ||
int * | , | ||
doublecomplex ** | , | ||
int * | , | ||
FILE * | , | ||
gridinfo_t * | |||
) |
int zcreate_matrix_postfix | ( | SuperMatrix * | A, |
int | nrhs, | ||
doublecomplex ** | rhs, | ||
int * | ldb, | ||
doublecomplex ** | x, | ||
int * | ldx, | ||
FILE * | fp, | ||
char * | postfix, | ||
gridinfo_t * | grid | ||
) |
int zcreate_matrix_postfix3d | ( | SuperMatrix * | A, |
int | nrhs, | ||
doublecomplex ** | rhs, | ||
int * | ldb, | ||
doublecomplex ** | x, | ||
int * | ldx, | ||
FILE * | fp, | ||
char * | postfix, | ||
gridinfo3d_t * | grid3d | ||
) |
int zcreate_matrix_rb | ( | SuperMatrix * | , |
int | , | ||
doublecomplex ** | , | ||
int * | , | ||
doublecomplex ** | , | ||
int * | , | ||
FILE * | , | ||
gridinfo_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 | |||
) |
int zDeAllocGlu_3d | ( | zLUstruct_t * | LUstruct | ) |
int zDeAllocLlu_3d | ( | int_t | n, |
zLUstruct_t * | LUstruct, | ||
gridinfo3d_t * | grid3d | ||
) |
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 | ||
) |
void zDestroy_A3d_gathered_on_2d | ( | zSOLVEstruct_t * | SOLVEstruct, |
gridinfo3d_t * | grid3d | ||
) |
void zDestroy_LU | ( | int_t | n, |
gridinfo_t * | grid, | ||
zLUstruct_t * | LUstruct | ||
) |
Destroy distributed L & U matrices.
void zDestroy_Tree | ( | int_t | n, |
gridinfo_t * | grid, | ||
zLUstruct_t * | LUstruct | ||
) |
Destroy broadcast and reduction trees used in triangular solve.
void zDestroy_trf3Dpartition | ( | ztrf3Dpartition_t * | trf3Dpartition, |
gridinfo3d_t * | grid3d | ||
) |
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 | ||
) |
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).
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)
void zfill_dist | ( | doublecomplex * | a, |
int_t | alen, | ||
doublecomplex | dval | ||
) |
Fills a doublecomplex precision array with a given value.
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.
int zfreeDiagFactBufsArr | ( | int_t | mxLeafNode, |
zdiagFactBufs_t ** | dFBufs | ||
) |
int zfreeScuBufs | ( | zscuBufs_t * | scuBufs | ) |
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 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 | ||
) |
int_t zgatherAllFactoredLU | ( | ztrf3Dpartition_t * | trf3Dpartition, |
zLUstruct_t * | LUstruct, | ||
gridinfo3d_t * | grid3d, | ||
SCT_t * | SCT | ||
) |
int_t zgatherAllFactoredLUFr | ( | int_t * | myZeroTrIdxs, |
sForest_t * | sForests, | ||
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 | ||
) |
void zGatherNRformat_loc3d | ( | fact_t | Fact, |
NRformat_loc * | A, | ||
doublecomplex * | B, | ||
int | ldb, | ||
int | nrhs, | ||
gridinfo3d_t * | grid3d, | ||
NRformat_loc3d ** | |||
) |
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 * | |||
) |
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 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 * | |||
) |
void zGenXtrue_dist | ( | int_t | n, |
int_t | nrhs, | ||
doublecomplex * | x, | ||
int_t | ldx | ||
) |
void zgeru_ | ( | const int * | , |
const int * | , | ||
const doublecomplex * | , | ||
const doublecomplex * | , | ||
const int * | , | ||
const doublecomplex * | , | ||
const int * | , | ||
doublecomplex * | , | ||
const int * | |||
) |
doublecomplex * zgetBigU | ( | superlu_dist_options_t * | , |
int_t | , | ||
gridinfo_t * | , | ||
zLUstruct_t * | |||
) |
doublecomplex * zgetBigV | ( | int_t | , |
int_t | |||
) |
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 =====================================================================
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 zIBcast_UPanel | ( | int_t | k, |
int_t | k0, | ||
int_t * | usub, | ||
doublecomplex * | uval, | ||
gridinfo_t * | , | ||
int * | msgcnt, | ||
MPI_Request * | , | ||
int * | ToSendD, | ||
int | |||
) |
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 | ||
) |
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.
int_t zinit3DLUstruct | ( | int_t * | myTreeIdxs, |
int_t * | myZeroTrIdxs, | ||
int_t * | nodeCount, | ||
int_t ** | nodeList, | ||
zLUstruct_t * | LUstruct, | ||
gridinfo3d_t * | grid3d | ||
) |
void zinit3DLUstructForest | ( | int_t * | myTreeIdxs, |
int_t * | myZeroTrIdxs, | ||
sForest_t ** | sForests, | ||
zLUstruct_t * | LUstruct, | ||
gridinfo3d_t * | grid3d | ||
) |
void zInit_HyP | ( | HyP_t * | HyP, |
zLocalLU_t * | Llu, | ||
int_t | mcb, | ||
int_t | mrb | ||
) |
int_t zinitDiagFactBufs | ( | int_t | ldt, |
zdiagFactBufs_t * | dFBuf | ||
) |
zdiagFactBufs_t ** zinitDiagFactBufsArr | ( | int_t | mxLeafNode, |
int_t | ldt, | ||
gridinfo_t * | grid | ||
) |
int_t zinitScuBufs | ( | superlu_dist_options_t * | , |
int_t | ldt, | ||
int_t | num_threads, | ||
int_t | nsupers, | ||
zscuBufs_t * | , | ||
zLUstruct_t * | , | ||
gridinfo_t * | |||
) |
ztrf3Dpartition_t * zinitTrf3Dpartition | ( | int_t | nsupers, |
superlu_dist_options_t * | options, | ||
zLUstruct_t * | LUstruct, | ||
gridinfo3d_t * | grid3d | ||
) |
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 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_UDiagBlock | ( | int_t | k0, |
doublecomplex * | ublk_ptr, | ||
int_t | size, | ||
int_t | src, | ||
MPI_Request * | , | ||
gridinfo_t * | , | ||
SCT_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 zISend_LDiagBlock | ( | int_t | k0, |
doublecomplex * | lblk_ptr, | ||
int_t | size, | ||
MPI_Request * | , | ||
gridinfo_t * | , | ||
int | |||
) |
int_t zISend_UDiagBlock | ( | int_t | k0, |
doublecomplex * | ublk_ptr, | ||
int_t | size, | ||
MPI_Request * | , | ||
gridinfo_t * | , | ||
int | |||
) |
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. =====================================================================
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. =====================================================================
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).
int zLluBufFreeArr | ( | int_t | numLA, |
zLUValSubBuf_t ** | LUvsbs | ||
) |
int_t zLluBufInit | ( | zLUValSubBuf_t * | , |
zLUstruct_t * | |||
) |
zLUValSubBuf_t ** zLluBufInitArr | ( | int_t | numLA, |
zLUstruct_t * | LUstruct | ||
) |
int_t zLPanelTrSolve | ( | int_t | k, |
int_t * | factored_L, | ||
doublecomplex * | BlockUFactor, | ||
gridinfo_t * | , | ||
zLUstruct_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 zLpanelUpdate | ( | int_t | off0, |
int_t | nsupc, | ||
doublecomplex * | ublk_ptr, | ||
int_t | ld_ujrow, | ||
doublecomplex * | lusup, | ||
int_t | nsupr, | ||
SCT_t * | |||
) |
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 | ||
) |
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 | ||
) |
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 | ||
) |
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].
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].
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].
void zLUstructFree | ( | zLUstruct_t * | LUstruct | ) |
Deallocate LUstruct.
void zLUstructInit | ( | const | int_t, |
zLUstruct_t * | LUstruct | ||
) |
Allocate storage in LUstruct.
int_t zp3dCollect | ( | int_t | layer, |
int_t | n, | ||
zLUstruct_t * | LUstruct, | ||
gridinfo3d_t * | grid3d | ||
) |
int_t zp3dScatter | ( | int_t | n, |
zLUstruct_t * | LUstruct, | ||
gridinfo3d_t * | grid3d | ||
) |
int_t zPackLBlock | ( | int_t | k, |
doublecomplex * | Dest, | ||
Glu_persist_t * | , | ||
gridinfo_t * | , | ||
zLocalLU_t * | |||
) |
void zPrint_CompCol_Matrix_dist | ( | SuperMatrix * | ) |
int zPrint_CompRowLoc_Matrix_dist | ( | SuperMatrix * | ) |
void zPrint_Dense_Matrix_dist | ( | SuperMatrix * | ) |
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.
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.
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:
int zread_binary | ( | FILE * | fp, |
int_t * | m, | ||
int_t * | n, | ||
int_t * | nnz, | ||
doublecomplex ** | nzval, | ||
int_t ** | rowind, | ||
int_t ** | colptr | ||
) |
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)
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.
void zreadrb_dist | ( | int | iam, |
FILE * | fp, | ||
int_t * | nrow, | ||
int_t * | ncol, | ||
int_t * | nonz, | ||
doublecomplex ** | nzval, | ||
int_t ** | rowind, | ||
int_t ** | colptr | ||
) |
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.
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.
int_t zRecv_UDiagBlock | ( | int_t | k0, |
doublecomplex * | ublk_ptr, | ||
int_t | size, | ||
int_t | src, | ||
gridinfo_t * | , | ||
SCT_t * | , | ||
int | |||
) |
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 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 | ||
) |
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 | ||
) |
int zscal_ | ( | const int * | n, |
const doublecomplex * | alpha, | ||
doublecomplex * | dx, | ||
const int * | incx | ||
) |
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.
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.
void zScalePermstructFree | ( | zScalePermstruct_t * | ScalePermstruct | ) |
Deallocate ScalePermstruct.
void zScalePermstructInit | ( | const | int_t, |
const | int_t, | ||
zScalePermstruct_t * | ScalePermstruct | ||
) |
Allocate storage in ScalePermstruct.
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 zScatter_B3d | ( | NRformat_loc3d * | A3d, |
gridinfo3d_t * | grid3d | ||
) |
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 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 * | |||
) |
void zSolveFinalize | ( | superlu_dist_options_t * | options, |
zSOLVEstruct_t * | SOLVEstruct | ||
) |
Release the resources used for the solution phase.
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.
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 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 | ||
) |
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 | ||
) |
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 | ||
) |
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 ztrsm_ | ( | const char * | , |
const char * | , | ||
const char * | , | ||
const char * | , | ||
const int * | , | ||
const int * | , | ||
const doublecomplex * | , | ||
const doublecomplex * | , | ||
const int * | , | ||
doublecomplex * | , | ||
const int * | |||
) |
int ztrsv_ | ( | char * | , |
char * | , | ||
char * | , | ||
int * | , | ||
doublecomplex * | , | ||
int * | , | ||
doublecomplex * | , | ||
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 zUPanelTrSolve | ( | int_t | k, |
doublecomplex * | BlockLFactor, | ||
doublecomplex * | bigV, | ||
int_t | ldt, | ||
Ublock_info_t * | , | ||
gridinfo_t * | , | ||
zLUstruct_t * | , | ||
SuperLUStat_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 zWait_LRecv | ( | MPI_Request * | , |
int * | msgcnt, | ||
int * | msgcntsU, | ||
gridinfo_t * | , | ||
SCT_t * | |||
) |
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 * | |||
) |
void zZero_CompRowLoc_Matrix_dist | ( | SuperMatrix * | A | ) |
Sets all entries of a matrix to zero, A_{i,j}=0, for i,j=1,..,n.
void zZeroLblocks | ( | int | iam, |
int | n, | ||
gridinfo_t * | grid, | ||
zLUstruct_t * | LUstruct | ||
) |
Sets all entries of matrix L to zero.
int_t zzeroSetLU | ( | int_t | nnodes, |
int_t * | nodeList, | ||
zLUstruct_t * | , | ||
gridinfo3d_t * | |||
) |
void zZeroUblocks | ( | int | iam, |
int | n, | ||
gridinfo_t * | grid, | ||
zLUstruct_t * | LUstruct | ||
) |
Sets all entries of matrix U to zero.
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 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 zzSendLPanel | ( | int_t | k, |
int_t | receiver, | ||
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 | ||
) |