#ifndef __SUPERLU_UTIL /* allow multiple inclusions */ #define __SUPERLU_UTIL #include #include #include /* #ifndef __STDC__ #include #endif */ #include /*********************************************************************** * Macros ***********************************************************************/ #define FIRSTCOL_OF_SNODE(i) (xsup[i]) /* No of marker arrays used in the symbolic factorization, each of size n */ #define NO_MARKER 3 #define NUM_TEMPV(m,w,t,b) ( SUPERLU_MAX(m, (t + b)*w) ) #ifndef USER_ABORT #define USER_ABORT(msg) superlu_abort_and_exit(msg) #endif #define ABORT(err_msg) \ { char msg[256];\ sprintf(msg,"%s at line %d in file %s\n",err_msg,__LINE__, __FILE__);\ USER_ABORT(msg); } #ifndef USER_MALLOC #if 1 #define USER_MALLOC(size) superlu_malloc(size) #else /* The following may check out some uninitialized data */ #define USER_MALLOC(size) memset (superlu_malloc(size), '\x0F', size) #endif #endif #define SUPERLU_MALLOC(size) USER_MALLOC(size) #ifndef USER_FREE #define USER_FREE(addr) superlu_free(addr) #endif #define SUPERLU_FREE(addr) USER_FREE(addr) #define CHECK_MALLOC(where) { \ extern int superlu_malloc_total; \ printf("%s: malloc_total %d Bytes\n", \ where, superlu_malloc_total); \ } #define SUPERLU_MAX(x, y) ( (x) > (y) ? (x) : (y) ) #define SUPERLU_MIN(x, y) ( (x) < (y) ? (x) : (y) ) /*********************************************************************** * Constants ***********************************************************************/ #define EMPTY (-1) /*#define NO (-1)*/ #define FALSE 0 #define TRUE 1 /*********************************************************************** * Enumerate types ***********************************************************************/ typedef enum {NO, YES} yes_no_t; typedef enum {DOFACT, SamePattern, SamePattern_SameRowPerm, FACTORED} fact_t; typedef enum {NOROWPERM, LargeDiag, MY_PERMR} rowperm_t; typedef enum {NATURAL, MMD_ATA, MMD_AT_PLUS_A, COLAMD, MY_PERMC}colperm_t; typedef enum {NOTRANS, TRANS, CONJ} trans_t; typedef enum {NOEQUIL, ROW, COL, BOTH} DiagScale_t; typedef enum {NOREFINE, SINGLE=1, SLU_DOUBLE, EXTRA} IterRefine_t; typedef enum {LUSUP, UCOL, LSUB, USUB} MemType; typedef enum {HEAD, TAIL} stack_end_t; typedef enum {SYSTEM, USER} LU_space_t; /* * The following enumerate type is used by the statistics variable * to keep track of flop count and time spent at various stages. * * Note that not all of the fields are disjoint. */ typedef enum { COLPERM, /* find a column ordering that minimizes fills */ RELAX, /* find artificial supernodes */ ETREE, /* compute column etree */ EQUIL, /* equilibrate the original matrix */ FACT, /* perform LU factorization */ RCOND, /* estimate reciprocal condition number */ SOLVE, /* forward and back solves */ REFINE, /* perform iterative refinement */ SLU_FLOAT, /* time spent in floating-point operations */ TRSV, /* fraction of FACT spent in xTRSV */ GEMV, /* fraction of FACT spent in xGEMV */ FERR, /* estimate error bounds after iterative refinement */ NPHASES /* total number of phases */ } PhaseType; /*********************************************************************** * Type definitions ***********************************************************************/ typedef float flops_t; typedef unsigned char Logical; /* *-- This contains the options used to control the solve process. * * Fact (fact_t) * Specifies whether or not the factored form of the matrix * A is supplied on entry, and if not, how the matrix A should * be factorizaed. * = DOFACT: The matrix A will be factorized from scratch, and the * factors will be stored in L and U. * = SamePattern: The matrix A will be factorized assuming * that a factorization of a matrix with the same sparsity * pattern was performed prior to this one. Therefore, this * factorization will reuse column permutation vector * ScalePermstruct->perm_c and the column elimination tree * LUstruct->etree. * = SamePattern_SameRowPerm: The matrix A will be factorized * assuming that a factorization of a matrix with the same * sparsity pattern and similar numerical values was performed * prior to this one. Therefore, this factorization will reuse * both row and column scaling factors R and C, and the * both row and column permutation vectors perm_r and perm_c, * distributed data structure set up from the previous symbolic * factorization. * = FACTORED: On entry, L, U, perm_r and perm_c contain the * factored form of A. If DiagScale is not NOEQUIL, the matrix * A has been equilibrated with scaling factors R and C. * * Equil (yes_no_t) * Specifies whether to equilibrate the system (scale A's row and * columns to have unit norm). * * ColPerm (colperm_t) * Specifies what type of column permutation to use to reduce fill. * = NATURAL: use the natural ordering * = MMD_ATA: use minimum degree ordering on structure of A'*A * = MMD_AT_PLUS_A: use minimum degree ordering on structure of A'+A * = COLAMD: use approximate minimum degree column ordering * = MY_PERMC: use the ordering specified in ScalePermstruct->perm_c[] * * Trans (trans_t) * Specifies the form of the system of equations: * = NOTRANS: A * X = B (No transpose) * = TRANS: A**T * X = B (Transpose) * = CONJ: A**H * X = B (Transpose) * * IterRefine (IterRefine_t) * Specifies whether to perform iterative refinement. * = NO: no iterative refinement * = WorkingPrec: perform iterative refinement in working precision * = ExtraPrec: perform iterative refinement in extra precision * * PrintStat (yes_no_t) * Specifies whether to print the solver's statistics. * * DiagPivotThresh (double, in [0.0, 1.0]) (only for sequential SuperLU) * Specifies the threshold used for a diagonal entry to be an * acceptable pivot. * * PivotGrowth (yes_no_t) * Specifies whether to compute the reciprocal pivot growth. * * ConditionNumber (ues_no_t) * Specifies whether to compute the reciprocal condition number. * * RowPerm (rowperm_t) (only for SuperLU_DIST) * Specifies whether to permute rows of the original matrix. * = NO: not to permute the rows * = LargeDiag: make the diagonal large relative to the off-diagonal * = MY_PERMR: use the permutation given in ScalePermstruct->perm_r[] * * ReplaceTinyPivot (yes_no_t) (only for SuperLU_DIST) * Specifies whether to replace the tiny diagonals by * sqrt(epsilon)*||A|| during LU factorization. * * SolveInitialized (yes_no_t) (only for SuperLU_DIST) * Specifies whether the initialization has been performed to the * triangular solve. * * RefineInitialized (yes_no_t) (only for SuperLU_DIST) * Specifies whether the initialization has been performed to the * sparse matrix-vector multiplication routine needed in iterative * refinement. */ typedef struct { fact_t Fact; yes_no_t Equil; colperm_t ColPerm; trans_t Trans; IterRefine_t IterRefine; yes_no_t PrintStat; yes_no_t SymmetricMode; double DiagPivotThresh; yes_no_t PivotGrowth; yes_no_t ConditionNumber; rowperm_t RowPerm; yes_no_t ReplaceTinyPivot; yes_no_t SolveInitialized; yes_no_t RefineInitialized; } superlu_options_t; typedef struct { int *panel_histo; /* histogram of panel size distribution */ double *utime; /* running time at various phases */ flops_t *ops; /* operation count at various phases */ int TinyPivots; /* number of tiny pivots */ int RefineSteps; /* number of iterative refinement steps */ } SuperLUStat_t; /*********************************************************************** * Prototypes ***********************************************************************/ #ifdef __cplusplus extern "C" { #endif extern void Destroy_SuperMatrix_Store(SuperMatrix *); extern void Destroy_CompCol_Matrix(SuperMatrix *); extern void Destroy_CompRow_Matrix(SuperMatrix *); extern void Destroy_SuperNode_Matrix(SuperMatrix *); extern void Destroy_CompCol_Permuted(SuperMatrix *); extern void Destroy_Dense_Matrix(SuperMatrix *); extern void get_perm_c(int, SuperMatrix *, int *); extern void set_default_options(superlu_options_t *options); extern void sp_preorder (superlu_options_t *, SuperMatrix*, int*, int*, SuperMatrix*); extern void superlu_abort_and_exit(char*); extern void *superlu_malloc (size_t); extern int *intMalloc (int); extern int *intCalloc (int); extern void superlu_free (void*); extern void SetIWork (int, int, int, int *, int **, int **, int **, int **, int **, int **, int **); extern int sp_coletree (int *, int *, int *, int, int, int *); extern void relax_snode (const int, int *, const int, int *, int *); extern void heap_relax_snode (const int, int *, const int, int *, int *); extern void resetrep_col (const int, const int *, int *); extern int spcoletree (int *, int *, int *, int, int, int *); extern int *TreePostorder (int, int *); extern double SuperLU_timer_ (); extern int sp_ienv (int); extern int lsame_ (char *, char *); extern int xerbla_ (char *, int *); extern void ifill (int *, int, int); extern void snode_profile (int, int *); extern void super_stats (int, int *); extern void PrintSumm (char *, int, int, int); extern void StatInit(SuperLUStat_t *); extern void StatPrint (SuperLUStat_t *); extern void StatFree(SuperLUStat_t *); extern void print_panel_seg(int, int, int, int, int *, int *); extern void check_repfnz(int, int, int, int *); #ifdef __cplusplus } #endif #endif /* __SUPERLU_UTIL */