SUPER_LU
Sparse Linear Equation Solver

SUPER_LU is a C library which implements some very fast solvers for sparse systems of linear equations.

SUPER_LU contains a set of subroutines to solve a sparse linear system A*X=B. It uses Gaussian elimination with partial pivoting (GEPP). The columns of A may be preordered before factorization; the preordering for sparsity is completely separate from the factorization.

SUPER_LU is implemented in ANSI C, and must be compiled with an ANSI C compiler. It provides functionality for both real and complex matrices, in both single and double precision. The initial letter of a routine name indicates the arithmetic type and precision:

• S, such as sgstrf, is for single precision real arithmetic;
• D, such as dgstrf, is for double precision real arithmetic;
• C, such as cgstrf, is for single precision complex arithmetic;
• Z, such as zgstrf, is for double precision complex arithmetic.

SUPER_LU invokes routines from the BLAS (Basic Linear Algebra Subprograms). For best efficiency, a user should link SUPER_LU with an optimized version of the BLAS for the given machine architecture.

On the DEC/Compaq/HP Alpha, for instance, this can be done by linking with the Compaq Extended Math Library, or CXML.

Related Data and Programs:

HB, a data directory which contains examples of Harwell Boeing (HB) files, a sparse matrix file format;

MGMRES, a C library which applies the restarted GMRES algorithm to solve a sparse linear system, by Lili Ju.

SPARSE_CC, a data directory which contains a description and examples of the CC format, ("compressed column") for storing a sparse matrix, including a way to write the matrix as a set of three files.

SUPER_BLAS, a C library which implements some of the Basic Linear Algebra Subprograms for fast execution.

Usage:

In order to build your program that calls SUPER_LU, you need to use the appropriate command:

Usage with SUPER_LU + CXML library (Dec/Compaq/HP Alpha):

cc myprog.c -L$HOME/lib/$ARCH -lsuper_lu -lcxml -m

Usage with SUPER_LU + SUPER_BLAS library:

cc myprog.c -L$HOME/lib/$ARCH -lsuper_lu -lsuper_blas -m

Reference:

1. http://crd.lbl.gov/~xiaoye/SuperLU/ the SuperLU web site.
2. James Demmel, John Gilbert, Xiaoye Li,
   SuperLU Users's Guide,
   ../../pdf/super_lu.pdf
3. James Demmel, Stanley Eisenstat, John Gilbert, Xiaoye Li, Joseph Liu
   A Supernodal Approach to Sparse Partial Pivoting,
   SIAM Journal on Matrix Analysis and Applications,
   Volume 20, Number 3, pages 720-755, 1999,
   ../../pdf/super_lu_simax95.pdf

Source code:

The SUPER_LU include files are available, specifying the interface between the user's code and the library:

• Cnames.h..
• colamd.h.
• csp_defs.h, the include file for routines for single precision complex sparse matrices.
• dsp_defs.h, the include file for routines for double precision real sparse matrices.
• ssp_defs.h, the include file for routines for single precision real sparse matrices.
• supermatrix.h.
• util.h.
• zsp_defs.h, the include file for routines for double precision complex sparse matrices.

Examples and Tests:

• g10_rua.txt, a file in Harwell-Boeing sparse matrix format, containing a real 100x100 matrix with 460 nonzero entries;
• cmat_cua.txt, a file in Harwell-Boeing sparse matrix format, containing a complex 1280x1280 matrix with 22,778 nonzero entries;

SUPER_LU_S0 is a simple 5 by 5 example using single precision real arithmetic. The matrix is set up directly in the code. The basic SGSSV solver is used. Files you may copy include:

• super_lu_s0.c, the calling program;
• super_lu_s0.sh, commands to compile, link and run the calling program;
• super_lu_s0_output.txt, the sample output.

SUPER_LU_S1 is a single precision example using the G10_RUA matrix. The basic SGSSV solver is used. Files you may copy include:

• super_lu_s1.c, the calling program;
• super_lu_s1.sh, commands to compile, link and run the calling program;
• super_lu_s1_output.txt, the sample output.

SUPER_LU_S2 is a single precision example using the G10_RUA matrix. The symmetric solver option is used. The "basic" SGSSV solver is used. Files you may copy include:

• super_lu_s2.c, the calling program;
• super_lu_s2.sh, commands to compile, link and run the calling program;
• super_lu_s2_output.txt, the sample output.

SUPER_LU_S3 is a single precision example using the G10_RUA matrix. The SGSSVX "expert" solver is used. Files you may copy include:

• super_lu_s3.c, the calling program;
• super_lu_s3.sh, commands to compile, link and run the calling program;
• super_lu_s3_output.txt, the sample output.

SUPER_LU_S4 is a single precision example using the G10_RUA matrix. The SGSSVX "expert" solver is used to factor the matrix on one call, and solve a linear system on another call. Files you may copy include:

• super_lu_s4.c, the calling program;
• super_lu_s4.sh, commands to compile, link and run the calling program;
• super_lu_s4_output.txt, the sample output.

SUPER_LU_S5 is a single precision example using the G10_RUA matrix. The SGSSVX "expert" solver is used to factor and solve a linear system A*X=B. Then, a second call is made to solve a linear system A1*X=B1. As part of the second call, the user informs SGSSVX that A1 shares the sparsity pattern of A, which allows SGSSVX to carry out the new calculation more efficiently. Files you may copy include:

• super_lu_s5.c, the calling program;
• super_lu_s5.sh, commands to compile, link and run the calling program;
• super_lu_s5_output.txt, the sample output.

SUPER_LU_D0 is a simple 5 by 5 example using double precision real arithmetic. The matrix is set up directly in the code. The "basic" DGSSV solver is used. Files you may copy include:

• super_lu_d0.c, the calling program;
• super_lu_d0.sh, commands to compile, link and run the calling program;
• super_lu_d0_output.txt, the sample output.

SUPER_LU_D1 is a double precision example using the G10_RUA matrix. The "basic" DGSSV solver is used. Files you may copy include:

• super_lu_d1.c, the calling program;
• super_lu_d1.sh, commands to compile, link and run the calling program;
• super_lu_d1_output.txt, the sample output.

SUPER_LU_D2 is a double precision example using the G10_RUA matrix. The "basic" DGSSV solver is used. The symmetric solver option is used. Files you may copy include:

• super_lu_d2.c, the calling program;
• super_lu_d2.sh, commands to compile, link and run the calling program;
• super_lu_d2_output.txt, the sample output.

SUPER_LU_D3 is a double precision example using the G10_RUA matrix. The "expert" DGSSVX solver is used. Files you may copy include:

• super_lu_s3.c, the calling program;
• super_lu_d3.sh, commands to compile, link and run the calling program;
• super_lu_d3_output.txt, the sample output.

SUPER_LU_D4 is a double precision example using the G10_RUA matrix. The "expert" DGSSVX solver is used to factor the matrix on one call, and solve a linear system on another call. Files you may copy include:

• super_lu_d4.c, the calling program;
• super_lu_d4.sh, commands to compile, link and run the calling program;
• super_lu_d4_output.txt, the sample output.

SUPER_LU_D5 is a double precision example using the G10_RUA matrix. The "expert" DGSSVX solver is used to factor and solve a linear system A*X=B. Then, a second call is made to solve a linear system A1*X=B1. As part of the second call, the user informs DGSSVX that A1 shares the sparsity pattern of A, which allows DGSSVX to carry out the new calculation more efficiently. Files you may copy include:

• super_lu_d5.c, the calling program;
• super_lu_d5.sh, commands to compile, link and run the calling program;
• super_lu_d5_output.txt, the sample output.

You can go up one level to the C source codes.