SRC/supermatrix.h

Go to the documentation of this file.
00001 
00004 #ifndef __SUPERLU_SUPERMATRIX /* allow multiple inclusions */
00005 #define __SUPERLU_SUPERMATRIX
00006 
00007 
00008 /********************************************
00009  * The matrix types are defined as follows. *
00010  ********************************************/
00011 typedef enum {
00012     SLU_NC,    /* column-wise, no supernode */
00013     SLU_NCP,   /* column-wise, column-permuted, no supernode 
00014                   (The consecutive columns of nonzeros, after permutation,
00015                    may not be stored  contiguously.) */
00016     SLU_NR,    /* row-wize, no supernode */
00017     SLU_SC,    /* column-wise, supernode */
00018     SLU_SCP,   /* supernode, column-wise, permuted */    
00019     SLU_SR,    /* row-wise, supernode */
00020     SLU_DN,     /* Fortran style column-wise storage for dense matrix */
00021     SLU_NR_loc  /* distributed compressed row format  */ 
00022 } Stype_t;
00023 
00024 typedef enum {
00025     SLU_S,     /* single */
00026     SLU_D,     /* double */
00027     SLU_C,     /* single complex */
00028     SLU_Z      /* double complex */
00029 } Dtype_t;
00030 
00031 typedef enum {
00032     SLU_GE,    /* general */
00033     SLU_TRLU,  /* lower triangular, unit diagonal */
00034     SLU_TRUU,  /* upper triangular, unit diagonal */
00035     SLU_TRL,   /* lower triangular */
00036     SLU_TRU,   /* upper triangular */
00037     SLU_SYL,   /* symmetric, store lower half */
00038     SLU_SYU,   /* symmetric, store upper half */
00039     SLU_HEL,   /* Hermitian, store lower half */
00040     SLU_HEU    /* Hermitian, store upper half */
00041 } Mtype_t;
00042 
00043 typedef struct {
00044         Stype_t Stype; /* Storage type: interprets the storage structure 
00045                           pointed to by *Store. */
00046         Dtype_t Dtype; /* Data type. */
00047         Mtype_t Mtype; /* Matrix type: describes the mathematical property of 
00048                           the matrix. */
00049         int_t  nrow;   /* number of rows */
00050         int_t  ncol;   /* number of columns */
00051         void *Store;   /* pointer to the actual storage of the matrix */
00052 } SuperMatrix;
00053 
00054 /***********************************************
00055  * The storage schemes are defined as follows. *
00056  ***********************************************/
00057 
00058 /* Stype == SLU_NC (Also known as Harwell-Boeing sparse matrix format) */
00059 typedef struct {
00060     int_t  nnz;     /* number of nonzeros in the matrix */
00061     void *nzval;    /* pointer to array of nonzero values, packed by column */
00062     int_t  *rowind; /* pointer to array of row indices of the nonzeros */
00063     int_t  *colptr; /* pointer to array of beginning of columns in nzval[] 
00064                        and rowind[]  */
00065                     /* Note:
00066                        Zero-based indexing is used;
00067                        colptr[] has ncol+1 entries, the last one pointing
00068                        beyond the last column, so that colptr[ncol] = nnz. */
00069 } NCformat;
00070 
00071 /* Stype == SLU_NR */
00072 typedef struct {
00073     int_t  nnz;     /* number of nonzeros in the matrix */
00074     void *nzval;    /* pointer to array of nonzero values, packed by raw */
00075     int_t  *colind; /* pointer to array of columns indices of the nonzeros */
00076     int_t  *rowptr; /* pointer to array of beginning of rows in nzval[] 
00077                        and colind[]  */
00078                     /* Note:
00079                        Zero-based indexing is used;
00080                        rowptr[] has nrow+1 entries, the last one pointing
00081                        beyond the last row, so that rowptr[nrow] = nnz. */
00082 } NRformat;
00083 
00084 /* Stype == SLU_SC */
00085 typedef struct {
00086   int_t  nnz;        /* number of nonzeros in the matrix */
00087   int_t  nsuper;     /* number of supernodes, minus 1 */
00088   void *nzval;       /* pointer to array of nonzero values, packed by column */
00089   int_t *nzval_colptr;/* pointer to array of beginning of columns in nzval[] */
00090   int_t *rowind;     /* pointer to array of compressed row indices of 
00091                         rectangular supernodes */
00092   int_t *rowind_colptr;/* pointer to array of beginning of columns in rowind[] */
00093   int_t *col_to_sup;   /* col_to_sup[j] is the supernode number to which column 
00094                         j belongs; mapping from column to supernode number. */
00095   int_t *sup_to_col;   /* sup_to_col[s] points to the start of the s-th 
00096                         supernode; mapping from supernode number to column.
00097                         e.g.: col_to_sup: 0 1 2 2 3 3 3 4 4 4 4 4 4 (ncol=12)
00098                               sup_to_col: 0 1 2 4 7 12           (nsuper=4) */
00099                      /* Note:
00100                         Zero-based indexing is used;
00101                         nzval_colptr[], rowind_colptr[], col_to_sup and
00102                         sup_to_col[] have ncol+1 entries, the last one
00103                         pointing beyond the last column.
00104                         For col_to_sup[], only the first ncol entries are
00105                         defined. For sup_to_col[], only the first nsuper+2
00106                         entries are defined. */
00107 } SCformat;
00108 
00109 /* Stype == SLU_SCP */
00110 typedef struct {
00111   int_t  nnz;        /* number of nonzeros in the matrix */
00112   int_t  nsuper;     /* number of supernodes */
00113   void *nzval;       /* pointer to array of nonzero values, packed by column */
00114   int_t  *nzval_colbeg;/* nzval_colbeg[j] points to beginning of column j
00115                           in nzval[] */
00116   int_t  *nzval_colend;/* nzval_colend[j] points to one past the last element
00117                           of column j in nzval[] */
00118   int_t  *rowind;      /* pointer to array of compressed row indices of 
00119                           rectangular supernodes */
00120   int_t *rowind_colbeg;/* rowind_colbeg[j] points to beginning of column j
00121                           in rowind[] */
00122   int_t *rowind_colend;/* rowind_colend[j] points to one past the last element
00123                           of column j in rowind[] */
00124   int_t *col_to_sup;   /* col_to_sup[j] is the supernode number to which column
00125                           j belongs; mapping from column to supernode. */
00126   int_t *sup_to_colbeg; /* sup_to_colbeg[s] points to the start of the s-th 
00127                            supernode; mapping from supernode to column.*/
00128   int_t *sup_to_colend; /* sup_to_colend[s] points to one past the end of the
00129                            s-th supernode; mapping from supernode number to
00130                            column.
00131                         e.g.: col_to_sup: 0 1 2 2 3 3 3 4 4 4 4 4 4 (ncol=12)
00132                               sup_to_colbeg: 0 1 2 4 7              (nsuper=4)
00133                               sup_to_colend: 1 2 4 7 12                    */
00134                      /* Note:
00135                         Zero-based indexing is used;
00136                         nzval_colptr[], rowind_colptr[], col_to_sup and
00137                         sup_to_col[] have ncol+1 entries, the last one
00138                         pointing beyond the last column.         */
00139 } SCPformat;
00140 
00141 /* Stype == SLU_NCP */
00142 typedef struct {
00143     int_t nnz;    /* number of nonzeros in the matrix */
00144     void *nzval;  /* pointer to array of nonzero values, packed by column */
00145     int_t *rowind;/* pointer to array of row indices of the nonzeros */
00146                   /* Note: nzval[]/rowind[] always have the same length */
00147     int_t *colbeg;/* colbeg[j] points to the beginning of column j in nzval[] 
00148                      and rowind[]  */
00149     int_t *colend;/* colend[j] points to one past the last element of column
00150                      j in nzval[] and rowind[]  */
00151                   /* Note:
00152                      Zero-based indexing is used;
00153                      The consecutive columns of the nonzeros may not be 
00154                      contiguous in storage, because the matrix has been 
00155                      postmultiplied by a column permutation matrix. */
00156 } NCPformat;
00157 
00158 /* Stype == SLU_DN */
00159 typedef struct {
00160     int_t lda;    /* leading dimension */
00161     void *nzval;  /* array of size lda*ncol to represent a dense matrix */
00162 } DNformat;
00163 
00164 /* Stype == SLU_NR_loc (Distributed Compressed Row Format) */
00165 typedef struct {
00166     int_t nnz_loc;   /* number of nonzeros in the local submatrix */
00167     int_t m_loc;     /* number of rows local to this processor */
00168     int_t fst_row;   /* global index of the first row */
00169     void  *nzval;    /* pointer to array of nonzero values, packed by row */
00170     int_t *rowptr;   /* pointer to array of beginning of rows in nzval[] 
00171                         and colind[]  */
00172     int_t *colind;   /* pointer to array of column indices of the nonzeros */
00173                      /* Note:
00174                         Zero-based indexing is used;
00175                         rowptr[] has n_loc + 1 entries, the last one pointing
00176                         beyond the last row, so that rowptr[n_loc] = nnz_loc.*/
00177 } NRformat_loc;
00178 
00179 
00180 #endif  /* __SUPERLU_SUPERMATRIX */

Generated on Fri Aug 1 22:40:39 2008 for SuperLU by  doxygen 1.4.6