4f1c674ee0
http://crd.lbl.gov/~xiaoye/SuperLU/ This is a library to solve sparse matrix systems (type A*x=B). It is able to solve large systems very FAST. Only the necessary parts of the library are included to limit file size and compilation time. This means the example files, fortran interface, test files, matlab interface, cblas library, complex number part and build system have been left out. All (gcc) warnings have been fixed too. This library will be used for LSCM UV unwrapping. With this library, LSCM unwrapping can be calculated in a split second, making the unwrapping proces much more interactive. Added OpenNL (Open Numerical Libary): http://www.loria.fr/~levy/OpenNL/ OpenNL is a library to easily construct and solve sparse linear systems. We use a stripped down version, as an interface to SuperLU. This library was kindly given to use by Bruno Levy.
268 lines
10 KiB
C
268 lines
10 KiB
C
#ifndef __SUPERLU_UTIL /* allow multiple inclusions */
|
|
#define __SUPERLU_UTIL
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
/*
|
|
#ifndef __STDC__
|
|
#include <malloc.h>
|
|
#endif
|
|
*/
|
|
#include <assert.h>
|
|
|
|
/***********************************************************************
|
|
* 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 */
|