00001 00012 #ifndef __SUPERLU_DEFS /* allow multiple inclusions */ 00013 #define __SUPERLU_DEFS 00014 00015 /* 00016 * File name: superlu_defs.h 00017 * Purpose: Definitions which are precision-neutral 00018 */ 00019 #ifdef _CRAY 00020 #include <fortran.h> 00021 #include <string.h> 00022 #endif 00023 #include <mpi.h> 00024 #include <stdlib.h> 00025 #include <stdio.h> 00026 00027 00028 /* Define my integer size int_t */ 00029 #ifdef _CRAY 00030 typedef short int_t; 00031 /*#undef int Revert back to int of default size. */ 00032 #define mpi_int_t MPI_SHORT 00033 #elif defined (_LONGINT) 00034 typedef long int int_t; 00035 #define mpi_int_t MPI_LONG 00036 #else /* Default */ 00037 typedef int int_t; 00038 #define mpi_int_t MPI_INT 00039 #endif 00040 00041 /*********************************************************************** 00042 * Enumerated types 00043 ***********************************************************************/ 00044 /*typedef enum {FALSE, TRUE} boolean_t;*/ 00045 typedef enum {NO, YES} yes_no_t; 00046 typedef enum {DOFACT, SamePattern, SamePattern_SameRowPerm, FACTORED} fact_t; 00047 typedef enum {NOROWPERM, LargeDiag, MY_PERMR} rowperm_t; 00048 typedef enum {NATURAL, MMD_AT_PLUS_A, MMD_ATA, METIS_AT_PLUS_A, 00049 PARMETIS, MY_PERMC} colperm_t; 00050 typedef enum {NOTRANS, TRANS, CONJ} trans_t; 00051 typedef enum {NOEQUIL, ROW, COL, BOTH} DiagScale_t; 00052 typedef enum {NOREFINE, SINGLE=1, DOUBLE, EXTRA} IterRefine_t; 00053 typedef enum {LUSUP, UCOL, LSUB, USUB} MemType; 00054 typedef enum {HEAD, TAIL} stack_end_t; 00055 typedef enum {SYSTEM, USER} LU_space_t; 00056 00057 #include "Cnames.h" 00058 #include "supermatrix.h" 00059 #include "util_dist.h" 00060 #include "psymbfact.h" 00061 00062 00063 /*********************************************************************** 00064 * Constants 00065 ***********************************************************************/ 00066 /* 00067 * For each block column of L, the index[] array contains both the row 00068 * subscripts and the integers describing the size of the blocks. 00069 * The organization of index[] looks like: 00070 * 00071 * [ BLOCK COLUMN HEADER (size BC_HEADER) 00072 * number of blocks 00073 * number of row subscripts, i.e., LDA of nzval[] 00074 * BLOCK 0 <---- 00075 * BLOCK DESCRIPTOR (of size LB_DESCRIPTOR) | 00076 * block number (global) | 00077 * number of full rows in the block | 00078 * actual row subscripts | 00079 * BLOCK 1 | Repeat ... 00080 * BLOCK DESCRIPTOR | number of blocks 00081 * block number (global) | 00082 * number of full rows in the block | 00083 * actual row subscripts | 00084 * . | 00085 * . | 00086 * . <---- 00087 * ] 00088 * 00089 * For each block row of U, the organization of index[] looks like: 00090 * 00091 * [ BLOCK ROW HEADER (of size BR_HEADER) 00092 * number of blocks 00093 * number of entries in nzval[] 00094 * number of entries in index[] 00095 * BLOCK 0 <---- 00096 * BLOCK DESCRIPTOR (of size UB_DESCRIPTOR) | 00097 * block number (global) | 00098 * number of nonzeros in the block | 00099 * actual fstnz subscripts | 00100 * BLOCK 1 | Repeat ... 00101 * BLOCK DESCRIPTOR | number of blocks 00102 * block number (global) | 00103 * number of nonzeros in the block | 00104 * actual fstnz subscripts | 00105 * . | 00106 * . | 00107 * . <---- 00108 * ] 00109 * 00110 */ 00111 #define BC_HEADER 2 00112 #define LB_DESCRIPTOR 2 00113 #define BR_HEADER 3 00114 #define UB_DESCRIPTOR 2 00115 #define NBUFFERS 5 00116 00117 /* 00118 * Communication tags 00119 */ 00120 /* For numeric factorization. */ 00121 #define NTAGS 10000 00122 #define UjROW 10 00123 #define UkSUB 11 00124 #define UkVAL 12 00125 #define LkSUB 13 00126 #define LkVAL 14 00127 #define LkkDIAG 15 00128 /* For triangular solves. */ 00129 #define XK_H 1 /* The header preceeding each X block. */ 00130 #define LSUM_H 1 /* The header preceeding each MOD block. */ 00131 #define GSUM 20 00132 #define Xk 21 00133 #define Yk 22 00134 #define LSUM 23 00135 00136 /* 00137 * Communication scopes 00138 */ 00139 #define COMM_ALL 100 00140 #define COMM_COLUMN 101 00141 #define COMM_ROW 102 00142 00143 /* 00144 * Matrix distribution for sparse matrix-vector multiplication 00145 */ 00146 #define SUPER_LINEAR 11 00147 #define SUPER_BLOCK 12 00148 00149 /* 00150 * No of marker arrays used in the symbolic factorization, each of size n 00151 */ 00152 #define NO_MARKER 3 00153 00154 00155 00156 /*********************************************************************** 00157 * Macros 00158 ***********************************************************************/ 00159 #define IAM(comm) { int rank; MPI_Comm_rank ( comm, &rank ); rank}; 00160 #define MYROW(iam,grid) ( (iam) / grid->npcol ) 00161 #define MYCOL(iam,grid) ( (iam) % grid->npcol ) 00162 #define BlockNum(i) ( supno[i] ) 00163 #define FstBlockC(bnum) ( xsup[bnum] ) 00164 #define SuperSize(bnum) ( xsup[bnum+1]-xsup[bnum] ) 00165 #define LBi(bnum,grid) ( (bnum)/grid->nprow )/* Global to local block rowwise */ 00166 #define LBj(bnum,grid) ( (bnum)/grid->npcol )/* Global to local block columnwise*/ 00167 #define PROW(bnum,grid) ( (bnum) % grid->nprow ) 00168 #define PCOL(bnum,grid) ( (bnum) % grid->npcol ) 00169 #define PNUM(i,j,grid) ( (i)*grid->npcol + j ) /* Process number at coord(i,j) */ 00170 #define CEILING(a,b) ( ((a)%(b)) ? ((a)/(b) + 1) : ((a)/(b)) ) 00171 /* For triangular solves */ 00172 #define RHS_ITERATE(i) \ 00173 for (i = 0; i < nrhs; ++i) 00174 #define X_BLK(i) \ 00175 ilsum[i] * nrhs + (i+1) * XK_H 00176 #define LSUM_BLK(i) \ 00177 ilsum[i] * nrhs + (i+1) * LSUM_H 00178 00179 #define SuperLU_timer_ SuperLU_timer_dist_ 00180 #define LOG2(x) (log10((double) x) / log10(2.0)) 00181 00182 00183 #if ( VAMPIR>=1 ) 00184 #define VT_TRACEON VT_traceon() 00185 #define VT_TRACEOFF VT_traceoff() 00186 #else 00187 #define VT_TRACEON 00188 #define VT_TRACEOFF 00189 #endif 00190 00191 00192 /*********************************************************************** 00193 * New data types 00194 ***********************************************************************/ 00195 00196 /* 00197 * Define the 2D mapping of matrix blocks to process grid. 00198 * 00199 * Process grid: 00200 * Processes are numbered (0 : P-1). 00201 * P = Pr x Pc, where Pr, Pc are the number of process rows and columns. 00202 * (pr,pc) is the coordinate of IAM; 0 <= pr < Pr, 0 <= pc < Pc. 00203 * 00204 * Matrix blocks: 00205 * Matrix is partitioned according to supernode partitions, both 00206 * column and row-wise. 00207 * The k-th block columns (rows) contains columns (rows) (s:t), where 00208 * s=xsup[k], t=xsup[k+1]-1. 00209 * Block A(I,J) contains 00210 * rows from (xsup[I]:xsup[I+1]-1) and 00211 * columns from (xsup[J]:xsup[J+1]-1) 00212 * 00213 * Mapping of matrix entry (i,j) to matrix block (I,J): 00214 * (I,J) = ( supno[i], supno[j] ) 00215 * 00216 * Mapping of matrix block (I,J) to process grid (pr,pc): 00217 * (pr,pc) = ( MOD(I,NPROW), MOD(J,NPCOL) ) 00218 * 00219 * (xsup[nsupers],supno[n]) are replicated on all processors. 00220 * 00221 */ 00222 00223 /*-- Communication subgroup */ 00224 typedef struct { 00225 MPI_Comm comm; /* MPI communicator */ 00226 int Np; /* number of processes */ 00227 int Iam; /* my process number */ 00228 } superlu_scope_t; 00229 00230 /*-- Process grid definition */ 00231 typedef struct { 00232 MPI_Comm comm; /* MPI communicator */ 00233 superlu_scope_t rscp; /* row scope */ 00234 superlu_scope_t cscp; /* column scope */ 00235 int iam; /* my process number in this scope */ 00236 int_t nprow; /* number of process rows */ 00237 int_t npcol; /* number of process columns */ 00238 } gridinfo_t; 00239 00240 00241 /* 00242 *-- The structures are determined by SYMBFACT and used thereafter. 00243 * 00244 * (xsup,supno) describes mapping between supernode and column: 00245 * xsup[s] is the leading column of the s-th supernode. 00246 * supno[i] is the supernode no to which column i belongs; 00247 * e.g. supno 0 1 2 2 3 3 3 4 4 4 4 4 (n=12) 00248 * xsup 0 1 2 4 7 12 00249 * Note: dfs will be performed on supernode rep. relative to the new 00250 * row pivoting ordering 00251 * 00252 * This is allocated during symbolic factorization SYMBFACT. 00253 */ 00254 typedef struct { 00255 int_t *xsup; 00256 int_t *supno; 00257 } Glu_persist_t; 00258 00259 /* 00260 *-- The structures are determined by SYMBFACT and used by DDISTRIBUTE. 00261 * 00262 * (xlsub,lsub): lsub[*] contains the compressed subscript of 00263 * rectangular supernodes; xlsub[j] points to the starting 00264 * location of the j-th column in lsub[*]. Note that xlsub 00265 * is indexed by column. 00266 * Storage: original row subscripts 00267 * 00268 * During the course of sparse LU factorization, we also use 00269 * (xlsub,lsub) for the purpose of symmetric pruning. For each 00270 * supernode {s,s+1,...,t=s+r} with first column s and last 00271 * column t, the subscript set 00272 * lsub[j], j=xlsub[s], .., xlsub[s+1]-1 00273 * is the structure of column s (i.e. structure of this supernode). 00274 * It is used for the storage of numerical values. 00275 * Furthermore, 00276 * lsub[j], j=xlsub[t], .., xlsub[t+1]-1 00277 * is the structure of the last column t of this supernode. 00278 * It is for the purpose of symmetric pruning. Therefore, the 00279 * structural subscripts can be rearranged without making physical 00280 * interchanges among the numerical values. 00281 * 00282 * However, if the supernode has only one column, then we 00283 * only keep one set of subscripts. For any subscript interchange 00284 * performed, similar interchange must be done on the numerical 00285 * values. 00286 * 00287 * The last column structures (for pruning) will be removed 00288 * after the numercial LU factorization phase. 00289 * 00290 * (xusub,usub): xusub[i] points to the starting location of column i 00291 * in usub[]. For each U-segment, only the row index of first nonzero 00292 * is stored in usub[]. 00293 * 00294 * Each U column consists of a number of full segments. Each full segment 00295 * starts from a leading nonzero, running up to the supernode (block) 00296 * boundary. (Recall that the column-wise supernode partition is also 00297 * imposed on the rows.) Because the segment is full, we don't store all 00298 * the row indices. Instead, only the leading nonzero index is stored. 00299 * The rest can be found together with xsup/supno pair. 00300 * For example, 00301 * usub[xsub[j+1]] - usub[xsub[j]] = number of segments in column j. 00302 * for any i in usub[], 00303 * supno[i] = block number in which i belongs to 00304 * xsup[supno[i]+1] = first row of the next block 00305 * The nonzeros of this segment are: 00306 * i, i+1 ... xsup[supno[i]+1]-1 (only i is stored in usub[]) 00307 * 00308 */ 00309 typedef struct { 00310 int_t *lsub; /* compressed L subscripts */ 00311 int_t *xlsub; 00312 int_t *usub; /* compressed U subscripts */ 00313 int_t *xusub; 00314 int_t nzlmax; /* current max size of lsub */ 00315 int_t nzumax; /* " " " usub */ 00316 LU_space_t MemModel; /* 0 - system malloc'd; 1 - user provided */ 00317 } Glu_freeable_t; 00318 00319 00320 /* 00321 *-- The structure used to store matrix A of the linear system and 00322 * several vectors describing the transformations done to matrix A. 00323 * 00324 * A (SuperMatrix*) 00325 * Matrix A in A*X=B, of dimension (A->nrow, A->ncol). 00326 * The number of linear equations is A->nrow. The type of A can be: 00327 * Stype = SLU_NC; Dtype = SLU_D; Mtype = SLU_GE. 00328 * 00329 * DiagScale (DiagScale_t) 00330 * Specifies the form of equilibration that was done. 00331 * = NOEQUIL: No equilibration. 00332 * = ROW: Row equilibration, i.e., A was premultiplied by diag(R). 00333 * = COL: Column equilibration, i.e., A was postmultiplied by diag(C). 00334 * = BOTH: Both row and column equilibration, i.e., A was replaced 00335 * by diag(R)*A*diag(C). 00336 * 00337 * R double*, dimension (A->nrow) 00338 * The row scale factors for A. 00339 * If DiagScale = ROW or BOTH, A is multiplied on the left by diag(R). 00340 * If DiagScale = NOEQUIL or COL, R is not defined. 00341 * 00342 * C double*, dimension (A->ncol) 00343 * The column scale factors for A. 00344 * If DiagScale = COL or BOTH, A is multiplied on the right by diag(C). 00345 * If DiagScale = NOEQUIL or ROW, C is not defined. 00346 * 00347 * perm_r (int*) dimension (A->nrow) 00348 * Row permutation vector which defines the permutation matrix Pr, 00349 * perm_r[i] = j means row i of A is in position j in Pr*A. 00350 * 00351 * perm_c (int*) dimension (A->ncol) 00352 * Column permutation vector, which defines the 00353 * permutation matrix Pc; perm_c[i] = j means column i of A is 00354 * in position j in A*Pc. 00355 * 00356 */ 00357 typedef struct { 00358 DiagScale_t DiagScale; 00359 double *R; 00360 double *C; 00361 int_t *perm_r; 00362 int_t *perm_c; 00363 } ScalePermstruct_t; 00364 00365 /* 00366 *-- This contains the options used to control the solve process. 00367 * 00368 * Fact (fact_t) 00369 * Specifies whether or not the factored form of the matrix 00370 * A is supplied on entry, and if not, how the matrix A should 00371 * be factorizaed. 00372 * = DOFACT: The matrix A will be factorized from scratch, and the 00373 * factors will be stored in L and U. 00374 * = SamePattern: The matrix A will be factorized assuming 00375 * that a factorization of a matrix with the same sparsity 00376 * pattern was performed prior to this one. Therefore, this 00377 * factorization will reuse column permutation vector 00378 * ScalePermstruct->perm_c and the column elimination tree 00379 * LUstruct->etree. 00380 * = SamePattern_SameRowPerm: The matrix A will be factorized 00381 * assuming that a factorization of a matrix with the same 00382 * sparsity pattern and similar numerical values was performed 00383 * prior to this one. Therefore, this factorization will reuse 00384 * both row and column scaling factors R and C, and the 00385 * both row and column permutation vectors perm_r and perm_c, 00386 * distributed data structure set up from the previous symbolic 00387 * factorization. 00388 * = FACTORED: On entry, L, U, perm_r and perm_c contain the 00389 * factored form of A. If DiagScale is not NOEQUIL, the matrix 00390 * A has been equilibrated with scaling factors R and C. 00391 * 00392 * Equil (yes_no_t) 00393 * Specifies whether to equilibrate the system (scale A's row and 00394 * columns to have unit norm). 00395 * 00396 * ColPerm (colperm_t) 00397 * Specifies what type of column permutation to use to reduce fill. 00398 * = NATURAL: use the natural ordering 00399 * = MMD_ATA: use minimum degree ordering on structure of A'*A 00400 * = MMD_AT_PLUS_A: use minimum degree ordering on structure of A'+A 00401 * = MY_PERMC: use the ordering specified in ScalePermstruct->perm_c[] 00402 * 00403 * Trans (trans_t) 00404 * Specifies the form of the system of equations: 00405 * = NOTRANS: A * X = B (No transpose) 00406 * = TRANS: A**T * X = B (Transpose) 00407 * = CONJ: A**H * X = B (Transpose) 00408 * 00409 * IterRefine (IterRefine_t) 00410 * Specifies whether to perform iterative refinement. 00411 * = NO: no iterative refinement 00412 * = WorkingPrec: perform iterative refinement in working precision 00413 * = ExtraPrec: perform iterative refinement in extra precision 00414 * 00415 * PrintStat (yes_no_t) 00416 * Specifies whether to print the solver's statistics. 00417 * 00418 * DiagPivotThresh (double, in [0.0, 1.0]) (only for sequential SuperLU) 00419 * Specifies the threshold used for a diagonal entry to be an 00420 * acceptable pivot. 00421 * 00422 * RowPerm (rowperm_t) (only for SuperLU_DIST) 00423 * Specifies whether to permute rows of the original matrix. 00424 * = NO: not to permute the rows 00425 * = LargeDiag: make the diagonal large relative to the off-diagonal 00426 * = MY_PERMR: use the permutation given in ScalePermstruct->perm_r[] 00427 * 00428 * ReplaceTinyPivot (yes_no_t) (only for SuperLU_DIST) 00429 * Specifies whether to replace the tiny diagonals by 00430 * sqrt(epsilon)*||A|| during LU factorization. 00431 * 00432 * SolveInitialized (yes_no_t) (only for SuperLU_DIST) 00433 * Specifies whether the initialization has been performed to the 00434 * triangular solve. 00435 * 00436 * RefineInitialized (yes_no_t) (only for SuperLU_DIST) 00437 * Specifies whether the initialization has been performed to the 00438 * sparse matrix-vector multiplication routine needed in iterative 00439 * refinement. 00440 */ 00441 typedef struct { 00442 fact_t Fact; 00443 yes_no_t Equil; 00444 yes_no_t ParSymbFact; 00445 colperm_t ColPerm; 00446 rowperm_t RowPerm; 00447 double DiagPivotThresh; 00448 IterRefine_t IterRefine; 00449 trans_t Trans; 00450 yes_no_t ReplaceTinyPivot; 00451 yes_no_t SolveInitialized; 00452 yes_no_t RefineInitialized; 00453 yes_no_t PrintStat; 00454 } superlu_options_t; 00455 00456 typedef struct { 00457 float for_lu; 00458 float total; 00459 int_t expansions; 00460 } mem_usage_t; 00461 00462 00463 /*********************************************************************** 00464 * Function prototypes 00465 ***********************************************************************/ 00466 00467 #ifdef __cplusplus 00468 extern "C" { 00469 #endif 00470 00471 extern void set_default_options_dist(superlu_options_t *); 00472 extern void print_options_dist(superlu_options_t *); 00473 extern void Destroy_CompCol_Matrix_dist(SuperMatrix *); 00474 extern void Destroy_SuperNode_Matrix_dist(SuperMatrix *); 00475 extern void Destroy_SuperMatrix_Store_dist(SuperMatrix *); 00476 extern void Destroy_CompCol_Permuted_dist(SuperMatrix *); 00477 extern void Destroy_CompRowLoc_Matrix_dist(SuperMatrix *); 00478 extern void Destroy_CompRow_Matrix_dist(SuperMatrix *); 00479 extern void sp_colorder (superlu_options_t*, SuperMatrix*, int_t*, int_t*, 00480 SuperMatrix*); 00481 extern int_t sp_coletree_dist (int_t *, int_t *, int_t *, int_t, int_t, 00482 int_t *); 00483 extern void countnz_dist (const int_t, int_t *, int_t *, int_t *, 00484 Glu_persist_t *, Glu_freeable_t *); 00485 extern int_t fixupL_dist (const int_t, const int_t *, Glu_persist_t *, 00486 Glu_freeable_t *); 00487 extern int_t *TreePostorder_dist (int_t, int_t *); 00488 extern float slamch_(char *); 00489 extern double dlamch_(char *); 00490 extern void *superlu_malloc_dist (size_t); 00491 extern void superlu_free_dist (void*); 00492 extern int_t *intMalloc_dist (int_t); 00493 extern int_t *intCalloc_dist (int_t); 00494 00495 /* Auxiliary routines */ 00496 extern double SuperLU_timer_ (); 00497 extern void superlu_abort_and_exit_dist(char *); 00498 extern int_t sp_ienv_dist (int_t); 00499 extern int lsame_ (char *, char *); 00500 extern int xerbla_ (char *, int *); 00501 extern void ifill_dist (int_t *, int_t, int_t); 00502 extern void super_stats_dist (int_t, int_t *); 00503 extern void ScalePermstructInit(const int_t, const int_t, 00504 ScalePermstruct_t *); 00505 extern void ScalePermstructFree(ScalePermstruct_t *); 00506 extern void superlu_gridinit(MPI_Comm, int_t, int_t, gridinfo_t *); 00507 extern void superlu_gridmap(MPI_Comm, int_t, int_t, int_t [], int_t, 00508 gridinfo_t *); 00509 extern void superlu_gridexit(gridinfo_t *); 00510 extern void get_perm_c_dist(int_t, int_t, SuperMatrix *, int_t *); 00511 extern void a_plus_at_dist(const int_t, const int_t, int_t *, int_t *, 00512 int_t *, int_t **, int_t **); 00513 extern void bcast_tree(void *, int, MPI_Datatype, int, int, 00514 gridinfo_t *, int, int *); 00515 extern int_t symbfact(superlu_options_t *, int, SuperMatrix *, int_t *, 00516 int_t *, Glu_persist_t *, Glu_freeable_t *); 00517 extern int_t symbfact_SubInit(fact_t, void *, int_t, int_t, int_t, int_t, 00518 Glu_persist_t *, Glu_freeable_t *); 00519 extern int_t symbfact_SubXpand(int_t, int_t, int_t, MemType, int_t *, 00520 Glu_freeable_t *); 00521 extern int_t symbfact_SubFree(Glu_freeable_t *); 00522 extern void get_diag_procs(int_t, Glu_persist_t *, gridinfo_t *, int_t *, 00523 int_t **, int_t **); 00524 extern int_t QuerySpace_dist(int_t, int_t, Glu_freeable_t *, mem_usage_t *); 00525 extern int xerbla_ (char *, int *); 00526 extern void pxerbla (char *, gridinfo_t *, int_t); 00527 extern void PStatInit(SuperLUStat_t *); 00528 extern void PStatFree(SuperLUStat_t *); 00529 extern void PStatPrint(superlu_options_t *, SuperLUStat_t *, gridinfo_t *); 00530 00531 00532 /* Prototypes for parallel symbolic factorization */ 00533 extern float symbfact_dist 00534 (int, int, SuperMatrix *, int_t *, int_t *, int_t *, int_t *, 00535 Pslu_freeable_t *, MPI_Comm *, MPI_Comm *, mem_usage_t *); 00536 00537 /* Get the column permutation using parmetis */ 00538 extern float get_perm_c_parmetis 00539 (SuperMatrix *, int_t *, int_t *, int, int, 00540 int_t **, int_t **, gridinfo_t *, MPI_Comm *); 00541 00542 /* Auxiliary routines for memory expansions used during 00543 the parallel symbolic factorization routine */ 00544 00545 extern int_t psymbfact_LUXpandMem 00546 (int_t, int_t, int_t, int_t, int_t, int_t, int_t, int_t, 00547 Pslu_freeable_t *, Llu_symbfact_t *, vtcsInfo_symbfact_t *, psymbfact_stat_t *); 00548 00549 extern int_t psymbfact_LUXpand 00550 (int_t, int_t, int_t, int_t, int_t *, int_t, int_t, int_t, int_t, 00551 Pslu_freeable_t *, Llu_symbfact_t *, vtcsInfo_symbfact_t *, psymbfact_stat_t *); 00552 00553 extern int_t psymbfact_LUXpand_RL 00554 (int_t, int_t, int_t, int_t, int_t, int_t, 00555 Pslu_freeable_t *, Llu_symbfact_t *, vtcsInfo_symbfact_t *, psymbfact_stat_t *); 00556 00557 extern int_t psymbfact_prLUXpand 00558 (int_t, int_t, 00559 MemType, Llu_symbfact_t *, psymbfact_stat_t *); 00560 00561 /* Routines for debugging */ 00562 extern void print_panel_seg_dist(int_t, int_t, int_t, int_t, int_t *, int_t *); 00563 extern void check_repfnz_dist(int_t, int_t, int_t, int_t *); 00564 extern int_t CheckZeroDiagonal(int_t, int_t *, int_t *, int_t *); 00565 extern void PrintDouble5(char *, int_t, double *); 00566 extern void PrintInt10(char *, int_t, int_t *); 00567 extern int file_PrintInt10(FILE *, char *, int_t, int_t *); 00568 00569 #ifdef __cplusplus 00570 } 00571 #endif 00572 00573 #endif /* __SUPERLU_DEFS */