Actual source code: petscmat.h
1: /* $Id: petscmat.h,v 1.228 2001/09/07 20:09:08 bsmith Exp $ */
2: /*
3: Include file for the matrix component of PETSc
4: */
5: #ifndef __PETSCMAT_H
7: #include petscvec.h
9: /*S
10: Mat - Abstract PETSc matrix object
12: Level: beginner
14: Concepts: matrix; linear operator
16: .seealso: MatCreate(), MatType, MatSetType()
17: S*/
18: typedef struct _p_Mat* Mat;
20: /*E
21: MatType - String with the name of a PETSc matrix or the creation function
22: with an optional dynamic library name, for example
23: http://www.mcs.anl.gov/petsc/lib.a:mymatcreate()
25: Level: beginner
27: .seealso: MatSetType(), Mat
28: E*/
29: #define MATSAME "same"
30: #define MATSEQMAIJ "seqmaij"
31: #define MATMPIMAIJ "mpimaij"
32: #define MATIS "is"
33: #define MATMPIROWBS "mpirowbs"
34: #define MATSEQDENSE "seqdense"
35: #define MATSEQAIJ "seqaij"
36: #define MATMPIAIJ "mpiaij"
37: #define MATSHELL "shell"
38: #define MATSEQBDIAG "seqbdiag"
39: #define MATMPIBDIAG "mpibdiag"
40: #define MATMPIDENSE "mpidense"
41: #define MATSEQBAIJ "seqbaij"
42: #define MATMPIBAIJ "mpibaij"
43: #define MATMPIADJ "mpiadj"
44: #define MATSEQSBAIJ "seqsbaij"
45: #define MATMPISBAIJ "mpisbaij"
46: #define MATDAAD "daad"
47: #define MATMFFD "mffd"
48: #define MATESI "esi"
49: #define MATPETSCESI "petscesi"
50: #define MATNORMAL "normal"
51: #define MATGLENN "glenn"
52: typedef char* MatType;
54: #define MAT_SER_SEQAIJ_BINARY "seqaij_binary"
55: #define MAT_SER_MPIAIJ_BINARY "mpiaij_binary"
56: typedef char *MatSerializeType;
58: /* Logging support */
59: #define MAT_FILE_COOKIE 1211216 /* used to indicate matrices in binary files */
60: extern int MAT_COOKIE;
61: extern int MATSNESMFCTX_COOKIE;
62: extern int MAT_FDCOLORING_COOKIE;
63: extern int MAT_PARTITIONING_COOKIE;
64: extern int MAT_NULLSPACE_COOKIE;
65: extern int MAT_Mult, MAT_MultMatrixFree, MAT_Mults, MAT_MultConstrained, MAT_MultAdd, MAT_MultTranspose;
66: extern int MAT_MultTransposeConstrained, MAT_MultTransposeAdd, MAT_Solve, MAT_Solves, MAT_SolveAdd, MAT_SolveTranspose;
67: extern int MAT_SolveTransposeAdd, MAT_Relax, MAT_ForwardSolve, MAT_BackwardSolve, MAT_LUFactor, MAT_LUFactorSymbolic;
68: extern int MAT_LUFactorNumeric, MAT_CholeskyFactor, MAT_CholeskyFactorSymbolic, MAT_CholeskyFactorNumeric, MAT_ILUFactor;
69: extern int MAT_ILUFactorSymbolic, MAT_ICCFactorSymbolic, MAT_Copy, MAT_Convert, MAT_Scale, MAT_AssemblyBegin;
70: extern int MAT_AssemblyEnd, MAT_SetValues, MAT_GetValues, MAT_GetRow, MAT_GetSubMatrices, MAT_GetColoring, MAT_GetOrdering;
71: extern int MAT_IncreaseOverlap, MAT_Partitioning, MAT_ZeroEntries, MAT_Load, MAT_View, MAT_AXPY, MAT_FDColoringCreate;
72: extern int MAT_FDColoringApply, MAT_Transpose;
74: EXTERN int MatInitializePackage(char *);
76: EXTERN int MatCreate(MPI_Comm,int,int,int,int,Mat*);
77: EXTERN int MatSetType(Mat,MatType);
78: EXTERN int MatSetFromOptions(Mat);
79: EXTERN int MatSetUpPreallocation(Mat);
80: EXTERN int MatRegisterAll(char*);
81: EXTERN int MatRegister(char*,char*,char*,int(*)(Mat));
82: EXTERN int MatSerializeRegister(const char [], const char [], const char [], int (*)(MPI_Comm, Mat *, PetscViewer, PetscTruth));
83: #if defined(PETSC_USE_DYNAMIC_LIBRARIES)
84: #define MatRegisterDynamic(a,b,c,d) MatRegister(a,b,c,0)
85: #define MatSerializeRegisterDynamic(a,b,c,d) MatSerializeRegister(a,b,c,0)
86: #else
87: #define MatRegisterDynamic(a,b,c,d) MatRegister(a,b,c,d)
88: #define MatSerializeRegisterDynamic(a,b,c,d) MatSerializeRegister(a,b,c,d)
89: #endif
90: extern PetscTruth MatRegisterAllCalled;
91: extern PetscFList MatList;
93: EXTERN PetscFList MatSerializeList;
94: EXTERN int MatSerializeRegisterAll(const char []);
95: EXTERN int MatSerializeRegisterDestroy(void);
96: EXTERN int MatSerializeRegisterAllCalled;
97: EXTERN int MatSerialize(MPI_Comm, Mat *, PetscViewer, PetscTruth);
98: EXTERN int MatSetSerializeType(Mat, MatSerializeType);
100: EXTERN int MatCreateSeqDense(MPI_Comm,int,int,PetscScalar*,Mat*);
101: EXTERN int MatCreateMPIDense(MPI_Comm,int,int,int,int,PetscScalar*,Mat*);
102: EXTERN int MatCreateSeqAIJ(MPI_Comm,int,int,int,int*,Mat*);
103: EXTERN int MatCreateMPIAIJ(MPI_Comm,int,int,int,int,int,int*,int,int*,Mat*);
104: EXTERN int MatCreateMPIRowbs(MPI_Comm,int,int,int,int*,Mat*);
105: EXTERN int MatCreateSeqBDiag(MPI_Comm,int,int,int,int,int*,PetscScalar**,Mat*);
106: EXTERN int MatCreateMPIBDiag(MPI_Comm,int,int,int,int,int,int*,PetscScalar**,Mat*);
107: EXTERN int MatCreateSeqBAIJ(MPI_Comm,int,int,int,int,int*,Mat*);
108: EXTERN int MatCreateMPIBAIJ(MPI_Comm,int,int,int,int,int,int,int*,int,int*,Mat*);
109: EXTERN int MatCreateMPIAdj(MPI_Comm,int,int,int*,int*,int *,Mat*);
110: EXTERN int MatCreateSeqSBAIJ(MPI_Comm,int,int,int,int,int*,Mat*);
111: EXTERN int MatCreateMPISBAIJ(MPI_Comm,int,int,int,int,int,int,int*,int,int*,Mat*);
112: EXTERN int MatCreateShell(MPI_Comm,int,int,int,int,void *,Mat*);
113: EXTERN int MatCreateAdic(MPI_Comm,int,int,int,int,int,void (*)(void),Mat*);
114: EXTERN int MatCreateNormal(Mat,Mat*);
115: EXTERN int MatDestroy(Mat);
117: EXTERN int MatPrintHelp(Mat);
118: EXTERN int MatGetPetscMaps(Mat,PetscMap*,PetscMap*);
120: /* ------------------------------------------------------------*/
121: EXTERN int MatSetValues(Mat,int,int*,int,int*,PetscScalar*,InsertMode);
122: EXTERN int MatSetValuesBlocked(Mat,int,int*,int,int*,PetscScalar*,InsertMode);
124: /*S
125: MatStencil - Data structure (C struct) for storing information about a single row or
126: column of a matrix as index on an associated grid.
128: Level: beginner
130: Concepts: matrix; linear operator
132: .seealso: MatSetValuesStencil(), MatSetStencil()
133: S*/
134: typedef struct {
135: int k,j,i,c;
136: } MatStencil;
138: EXTERN int MatSetValuesStencil(Mat,int,MatStencil*,int,MatStencil*,PetscScalar*,InsertMode);
139: EXTERN int MatSetValuesBlockedStencil(Mat,int,MatStencil*,int,MatStencil*,PetscScalar*,InsertMode);
140: EXTERN int MatSetStencil(Mat,int,int*,int*,int);
142: EXTERN int MatSetColoring(Mat,ISColoring);
143: EXTERN int MatSetValuesAdic(Mat,void*);
144: EXTERN int MatSetValuesAdifor(Mat,int,void*);
146: /*E
147: MatAssemblyType - Indicates if the matrix is now to be used, or if you plan
148: to continue to add values to it
150: Level: beginner
152: .seealso: MatAssemblyBegin(), MatAssemblyEnd()
153: E*/
154: typedef enum {MAT_FLUSH_ASSEMBLY=1,MAT_FINAL_ASSEMBLY=0} MatAssemblyType;
155: EXTERN int MatAssemblyBegin(Mat,MatAssemblyType);
156: EXTERN int MatAssemblyEnd(Mat,MatAssemblyType);
157: EXTERN int MatAssembled(Mat,PetscTruth*);
159: #define MatSetValue(v,i,j,va,mode)
160: 0; {int _ierr,_row = i,_col = j; PetscScalar _va = va;
161: _MatSetValues(v,1,&_row,1,&_col,&_va,mode);CHKERRQ(_ierr);
162: }
163: #define MatGetValue(v,i,j,va)
164: 0; {int _ierr,_row = i,_col = j;
165: _MatGetValues(v,1,&_row,1,&_col,&va);CHKERRQ(_ierr);
166: }
167: #define MatSetValueLocal(v,i,j,va,mode)
168: 0; {int _ierr,_row = i,_col = j; PetscScalar _va = va;
169: _MatSetValuesLocal(v,1,&_row,1,&_col,&_va,mode);CHKERRQ(_ierr);
170: }
171: /*E
172: MatOption - Options that may be set for a matrix and its behavior or storage
174: Level: beginner
176: Any additions/changes here MUST also be made in include/finclude/petscmat.h
178: .seealso: MatSetOption()
179: E*/
180: typedef enum {MAT_ROW_ORIENTED=1,MAT_COLUMN_ORIENTED=2,MAT_ROWS_SORTED=4,
181: MAT_COLUMNS_SORTED=8,MAT_NO_NEW_NONZERO_LOCATIONS=16,
182: MAT_YES_NEW_NONZERO_LOCATIONS=32,MAT_SYMMETRIC=64,
183: MAT_STRUCTURALLY_SYMMETRIC=65,MAT_NO_NEW_DIAGONALS=66,
184: MAT_YES_NEW_DIAGONALS=67,MAT_INODE_LIMIT_1=68,MAT_INODE_LIMIT_2=69,
185: MAT_INODE_LIMIT_3=70,MAT_INODE_LIMIT_4=71,MAT_INODE_LIMIT_5=72,
186: MAT_IGNORE_OFF_PROC_ENTRIES=73,MAT_ROWS_UNSORTED=74,
187: MAT_COLUMNS_UNSORTED=75,MAT_NEW_NONZERO_LOCATION_ERR=76,
188: MAT_NEW_NONZERO_ALLOCATION_ERR=77,MAT_USE_HASH_TABLE=78,
189: MAT_KEEP_ZEROED_ROWS=79,MAT_IGNORE_ZERO_ENTRIES=80,MAT_USE_INODES=81,
190: MAT_DO_NOT_USE_INODES=82} MatOption;
191: EXTERN int MatSetOption(Mat,MatOption);
192: EXTERN int MatGetType(Mat,MatType*);
194: EXTERN int MatGetValues(Mat,int,int*,int,int*,PetscScalar*);
195: EXTERN int MatGetRow(Mat,int,int *,int **,PetscScalar**);
196: EXTERN int MatRestoreRow(Mat,int,int *,int **,PetscScalar**);
197: EXTERN int MatGetColumn(Mat,int,int *,int **,PetscScalar**);
198: EXTERN int MatRestoreColumn(Mat,int,int *,int **,PetscScalar**);
199: EXTERN int MatGetColumnVector(Mat,Vec,int);
200: EXTERN int MatGetArray(Mat,PetscScalar **);
201: EXTERN int MatRestoreArray(Mat,PetscScalar **);
202: EXTERN int MatGetBlockSize(Mat,int *);
204: EXTERN int MatMult(Mat,Vec,Vec);
205: EXTERN int MatMultAdd(Mat,Vec,Vec,Vec);
206: EXTERN int MatMultTranspose(Mat,Vec,Vec);
207: EXTERN int MatMultTransposeAdd(Mat,Vec,Vec,Vec);
208: EXTERN int MatMultConstrained(Mat,Vec,Vec);
209: EXTERN int MatMultTransposeConstrained(Mat,Vec,Vec);
211: /*E
212: MatDuplicateOption - Indicates if a duplicated sparse matrix should have
213: its numerical values copied over or just its nonzero structure.
215: Level: beginner
217: Any additions/changes here MUST also be made in include/finclude/petscmat.h
219: .seealso: MatDuplicate()
220: E*/
221: typedef enum {MAT_DO_NOT_COPY_VALUES,MAT_COPY_VALUES} MatDuplicateOption;
223: EXTERN int MatConvertRegister(char*,char*,char*,int (*)(Mat,MatType,Mat*));
224: #if defined(PETSC_USE_DYNAMIC_LIBRARIES)
225: #define MatConvertRegisterDynamic(a,b,c,d) MatConvertRegister(a,b,c,0)
226: #else
227: #define MatConvertRegisterDynamic(a,b,c,d) MatConvertRegister(a,b,c,d)
228: #endif
229: EXTERN int MatConvertRegisterAll(char*);
230: EXTERN int MatConvertRegisterDestroy(void);
231: extern PetscTruth MatConvertRegisterAllCalled;
232: extern PetscFList MatConvertList;
233: EXTERN int MatConvert(Mat,MatType,Mat*);
234: EXTERN int MatDuplicate(Mat,MatDuplicateOption,Mat*);
236: /*E
237: MatStructure - Indicates if the matrix has the same nonzero structure
239: Level: beginner
241: Any additions/changes here MUST also be made in include/finclude/petscmat.h
243: .seealso: MatCopy(), SLESSetOperators(), PCSetOperators()
244: E*/
245: typedef enum {SAME_NONZERO_PATTERN,DIFFERENT_NONZERO_PATTERN,SAME_PRECONDITIONER} MatStructure;
247: EXTERN int MatCopy(Mat,Mat,MatStructure);
248: EXTERN int MatView(Mat,PetscViewer);
250: EXTERN int MatLoadRegister(char*,char*,char*,int (*)(PetscViewer,MatType,Mat*));
251: #if defined(PETSC_USE_DYNAMIC_LIBRARIES)
252: #define MatLoadRegisterDynamic(a,b,c,d) MatLoadRegister(a,b,c,0)
253: #else
254: #define MatLoadRegisterDynamic(a,b,c,d) MatLoadRegister(a,b,c,d)
255: #endif
256: EXTERN int MatLoadRegisterAll(char*);
257: EXTERN int MatLoadRegisterDestroy(void);
258: extern PetscTruth MatLoadRegisterAllCalled;
259: extern PetscFList MatLoadList;
260: EXTERN int MatLoad(PetscViewer,MatType,Mat*);
261: EXTERN int MatMerge(MPI_Comm,Mat,Mat*);
263: EXTERN int MatGetRowIJ(Mat,int,PetscTruth,int*,int **,int **,PetscTruth *);
264: EXTERN int MatRestoreRowIJ(Mat,int,PetscTruth,int *,int **,int **,PetscTruth *);
265: EXTERN int MatGetColumnIJ(Mat,int,PetscTruth,int*,int **,int **,PetscTruth *);
266: EXTERN int MatRestoreColumnIJ(Mat,int,PetscTruth,int *,int **,int **,PetscTruth *);
268: /*S
269: MatInfo - Context of matrix information, used with MatGetInfo()
271: In Fortran this is simply a double precision array of dimension MAT_INFO_SIZE
273: Level: intermediate
275: Concepts: matrix^nonzero information
277: .seealso: MatGetInfo(), MatInfoType
278: S*/
279: typedef struct {
280: PetscLogDouble rows_global,columns_global; /* number of global rows and columns */
281: PetscLogDouble rows_local,columns_local; /* number of local rows and columns */
282: PetscLogDouble block_size; /* block size */
283: PetscLogDouble nz_allocated,nz_used,nz_unneeded; /* number of nonzeros */
284: PetscLogDouble memory; /* memory allocated */
285: PetscLogDouble assemblies; /* number of matrix assemblies called */
286: PetscLogDouble mallocs; /* number of mallocs during MatSetValues() */
287: PetscLogDouble fill_ratio_given,fill_ratio_needed; /* fill ratio for LU/ILU */
288: PetscLogDouble factor_mallocs; /* number of mallocs during factorization */
289: } MatInfo;
291: /*E
292: MatInfoType - Indicates if you want information about the local part of the matrix,
293: the entire parallel matrix or the maximum over all the local parts.
295: Level: beginner
297: Any additions/changes here MUST also be made in include/finclude/petscmat.h
299: .seealso: MatGetInfo(), MatInfo
300: E*/
301: typedef enum {MAT_LOCAL=1,MAT_GLOBAL_MAX=2,MAT_GLOBAL_SUM=3} MatInfoType;
302: EXTERN int MatGetInfo(Mat,MatInfoType,MatInfo*);
303: EXTERN int MatValid(Mat,PetscTruth*);
304: EXTERN int MatGetDiagonal(Mat,Vec);
305: EXTERN int MatGetRowMax(Mat,Vec);
306: EXTERN int MatTranspose(Mat,Mat*);
307: EXTERN int MatPermute(Mat,IS,IS,Mat *);
308: EXTERN int MatPermuteSparsify(Mat,int,PetscReal,PetscReal,IS,IS,Mat *);
309: EXTERN int MatDiagonalScale(Mat,Vec,Vec);
310: EXTERN int MatDiagonalSet(Mat,Vec,InsertMode);
311: EXTERN int MatEqual(Mat,Mat,PetscTruth*);
313: EXTERN int MatNorm(Mat,NormType,PetscReal *);
314: EXTERN int MatZeroEntries(Mat);
315: EXTERN int MatZeroRows(Mat,IS,PetscScalar*);
316: EXTERN int MatZeroColumns(Mat,IS,PetscScalar*);
318: EXTERN int MatUseScaledForm(Mat,PetscTruth);
319: EXTERN int MatScaleSystem(Mat,Vec,Vec);
320: EXTERN int MatUnScaleSystem(Mat,Vec,Vec);
322: EXTERN int MatGetSize(Mat,int*,int*);
323: EXTERN int MatGetLocalSize(Mat,int*,int*);
324: EXTERN int MatGetOwnershipRange(Mat,int*,int*);
326: /*E
327: MatReuse - Indicates if matrices obtained from a previous call to MatGetSubMatrices()
328: or MatGetSubMatrix() are to be reused to store the new matrix values.
330: Level: beginner
332: Any additions/changes here MUST also be made in include/finclude/petscmat.h
334: .seealso: MatGetSubMatrices(), MatGetSubMatrix(), MatDestroyMatrices()
335: E*/
336: typedef enum {MAT_INITIAL_MATRIX,MAT_REUSE_MATRIX} MatReuse;
337: EXTERN int MatGetSubMatrices(Mat,int,IS *,IS *,MatReuse,Mat **);
338: EXTERN int MatDestroyMatrices(int,Mat **);
339: EXTERN int MatGetSubMatrix(Mat,IS,IS,int,MatReuse,Mat *);
341: EXTERN int MatIncreaseOverlap(Mat,int,IS *,int);
343: EXTERN int MatAXPY(PetscScalar *,Mat,Mat,MatStructure);
344: EXTERN int MatAYPX(PetscScalar *,Mat,Mat);
345: EXTERN int MatCompress(Mat);
347: EXTERN int MatScale(PetscScalar *,Mat);
348: EXTERN int MatShift(PetscScalar *,Mat);
350: EXTERN int MatSetLocalToGlobalMapping(Mat,ISLocalToGlobalMapping);
351: EXTERN int MatSetLocalToGlobalMappingBlock(Mat,ISLocalToGlobalMapping);
352: EXTERN int MatZeroRowsLocal(Mat,IS,PetscScalar*);
353: EXTERN int MatSetValuesLocal(Mat,int,int*,int,int*,PetscScalar*,InsertMode);
354: EXTERN int MatSetValuesBlockedLocal(Mat,int,int*,int,int*,PetscScalar*,InsertMode);
356: EXTERN int MatSetStashInitialSize(Mat,int,int);
358: EXTERN int MatInterpolateAdd(Mat,Vec,Vec,Vec);
359: EXTERN int MatInterpolate(Mat,Vec,Vec);
360: EXTERN int MatRestrict(Mat,Vec,Vec);
362: /*
363: These three (or four) macros MUST be used together. The third one closes the open { of the first one
364: */
365: #define MatPreallocateInitialize(comm,nrows,ncols,dnz,onz) 0;
366: {
367: int _4_ierr,__tmp = (nrows),__ctmp = (ncols),__rstart,__start,__end;
368: _4_PetscMalloc(2*__tmp*sizeof(int),&dnz);CHKERRQ(_4_ierr);onz = dnz + __tmp;
369: _4_PetscMemzero(dnz,2*__tmp*sizeof(int));CHKERRQ(_4_ierr);
370: _4_MPI_Scan(&__ctmp,&__end,1,MPI_INT,MPI_SUM,comm);CHKERRQ(_4_ierr); __start = __end - __ctmp;
371: _4_MPI_Scan(&__tmp,&__rstart,1,MPI_INT,MPI_SUM,comm);CHKERRQ(_4_ierr); __rstart = __rstart - __tmp;
373: #define MatPreallocateSymmetricInitialize(comm,nrows,ncols,dnz,onz) 0;
374: {
375: int _4_ierr,__tmp = (nrows),__ctmp = (ncols),__rstart,__end;
376: _4_PetscMalloc(2*__tmp*sizeof(int),&dnz);CHKERRQ(_4_ierr);onz = dnz + __tmp;
377: _4_PetscMemzero(dnz,2*__tmp*sizeof(int));CHKERRQ(_4_ierr);
378: _4_MPI_Scan(&__ctmp,&__end,1,MPI_INT,MPI_SUM,comm);CHKERRQ(_4_ierr);
379: _4_MPI_Scan(&__tmp,&__rstart,1,MPI_INT,MPI_SUM,comm);CHKERRQ(_4_ierr); __rstart = __rstart - __tmp;
381: #define MatPreallocateSetLocal(map,nrows,rows,ncols,cols,dnz,onz) 0;
382: {
383: int __l;
384: _4_ISLocalToGlobalMappingApply(map,nrows,rows,rows);CHKERRQ(_4_ierr);
385: _4_ISLocalToGlobalMappingApply(map,ncols,cols,cols);CHKERRQ(_4_ierr);
386: for (__l=0;__l<nrows;__l++) {
387: _4_MatPreallocateSet((rows)[__l],ncols,cols,dnz,onz);CHKERRQ(_4_ierr);
388: }
389: }
390:
391: #define MatPreallocateSymmetricSetLocal(map,nrows,rows,ncols,cols,dnz,onz) 0;
392: {
393: int __l;
394: _4_ISLocalToGlobalMappingApply(map,nrows,rows,rows);CHKERRQ(_4_ierr);
395: _4_ISLocalToGlobalMappingApply(map,ncols,cols,cols);CHKERRQ(_4_ierr);
396: for (__l=0;__l<nrows;__l++) {
397: _4_MatPreallocateSymmetricSet((rows)[__l],ncols,cols,dnz,onz);CHKERRQ(_4_ierr);
398: }
399: }
401: #define MatPreallocateSet(row,nc,cols,dnz,onz) 0;
402: { int __i;
403: for (__i=0; __i<nc; __i++) {
404: if (cols[__i] < __start || cols[__i] >= __end) onz[row - __rstart]++;
405: }
406: dnz[row - __rstart] = nc - onz[row - __rstart];
407: }
409: #define MatPreallocateSymmetricSet(row,nc,cols,dnz,onz) 0;
410: { int __i;
411: for (__i=0; __i<nc; __i++) {
412: if (cols[__i] >= __end) onz[row - __rstart]++;
413: else if (cols[__i] >= row) dnz[row - __rstart]++;
414: }
415: }
417: #define MatPreallocateFinalize(dnz,onz) 0;_4_PetscFree(dnz);CHKERRQ(_4_ierr);}
419: /* Routines unique to particular data structures */
420: EXTERN int MatShellGetContext(Mat,void **);
422: EXTERN int MatBDiagGetData(Mat,int*,int*,int**,int**,PetscScalar***);
423: EXTERN int MatSeqAIJSetColumnIndices(Mat,int *);
424: EXTERN int MatSeqBAIJSetColumnIndices(Mat,int *);
425: EXTERN int MatCreateSeqAIJWithArrays(MPI_Comm,int,int,int*,int*,PetscScalar *,Mat*);
427: EXTERN int MatSeqBAIJSetPreallocation(Mat,int,int,int*);
428: EXTERN int MatSeqSBAIJSetPreallocation(Mat,int,int,int*);
429: EXTERN int MatSeqAIJSetPreallocation(Mat,int,int*);
430: EXTERN int MatSeqDensePreallocation(Mat,PetscScalar*);
431: EXTERN int MatSeqBDiagSetPreallocation(Mat,int,int,int*,PetscScalar**);
432: EXTERN int MatSeqDenseSetPreallocation(Mat,PetscScalar*);
434: EXTERN int MatMPIBAIJSetPreallocation(Mat,int,int,int*,int,int*);
435: EXTERN int MatMPISBAIJSetPreallocation(Mat,int,int,int*,int,int*);
436: EXTERN int MatMPIAIJSetPreallocation(Mat,int,int*,int,int*);
437: EXTERN int MatMPIDensePreallocation(Mat,PetscScalar*);
438: EXTERN int MatMPIBDiagSetPreallocation(Mat,int,int,int*,PetscScalar**);
439: EXTERN int MatMPIAdjSetPreallocation(Mat,int*,int*,int*);
440: EXTERN int MatMPIDenseSetPreallocation(Mat,PetscScalar*);
441: EXTERN int MatMPIRowbsSetPreallocation(Mat,int,int*);
442: EXTERN int MatMPIAIJGetSeqAIJ(Mat,Mat*,Mat*,int**);
443: EXTERN int MatMPIBAIJGetSeqBAIJ(Mat,Mat*,Mat*,int**);
444: EXTERN int MatAdicSetLocalFunction(Mat,void (*)(void));
446: EXTERN int MatStoreValues(Mat);
447: EXTERN int MatRetrieveValues(Mat);
449: EXTERN int MatDAADSetCtx(Mat,void*);
451: /*
452: These routines are not usually accessed directly, rather solving is
453: done through the SLES, KSP and PC interfaces.
454: */
456: /*E
457: MatOrderingType - String with the name of a PETSc matrix ordering or the creation function
458: with an optional dynamic library name, for example
459: http://www.mcs.anl.gov/petsc/lib.a:orderingcreate()
461: Level: beginner
463: .seealso: MatGetOrdering()
464: E*/
465: typedef char* MatOrderingType;
466: #define MATORDERING_NATURAL "natural"
467: #define MATORDERING_ND "nd"
468: #define MATORDERING_1WD "1wd"
469: #define MATORDERING_RCM "rcm"
470: #define MATORDERING_QMD "qmd"
471: #define MATORDERING_ROWLENGTH "rowlength"
472: #define MATORDERING_DSC_ND "dsc_nd"
473: #define MATORDERING_DSC_MMD "dsc_mmd"
474: #define MATORDERING_DSC_MDF "dsc_mdf"
475: #define MATORDERING_CONSTRAINED "constrained"
476: #define MATORDERING_IDENTITY "identity"
477: #define MATORDERING_REVERSE "reverse"
479: EXTERN int MatGetOrdering(Mat,MatOrderingType,IS*,IS*);
480: EXTERN int MatOrderingRegister(char*,char*,char*,int(*)(Mat,MatOrderingType,IS*,IS*));
481: #if defined(PETSC_USE_DYNAMIC_LIBRARIES)
482: #define MatOrderingRegisterDynamic(a,b,c,d) MatOrderingRegister(a,b,c,0)
483: #else
484: #define MatOrderingRegisterDynamic(a,b,c,d) MatOrderingRegister(a,b,c,d)
485: #endif
486: EXTERN int MatOrderingRegisterDestroy(void);
487: EXTERN int MatOrderingRegisterAll(char*);
488: extern PetscTruth MatOrderingRegisterAllCalled;
489: extern PetscFList MatOrderingList;
491: EXTERN int MatReorderForNonzeroDiagonal(Mat,PetscReal,IS,IS);
493: EXTERN int MatCholeskyFactor(Mat,IS,PetscReal);
494: EXTERN int MatCholeskyFactorSymbolic(Mat,IS,PetscReal,Mat*);
495: EXTERN int MatCholeskyFactorNumeric(Mat,Mat*);
497: /*S
498: MatILUInfo - Data based into the matrix ILU factorization routines
500: In Fortran these are simply double precision arrays of size MAT_ILUINFO_SIZE
502: Notes: These are not usually directly used by users, instead use the PC type of ILU
503: All entries are double precision.
505: Level: developer
507: .seealso: MatILUFactorSymbolic(), MatILUFactor(), MatLUInfo, MatCholeskyInfo
509: S*/
510: typedef struct {
511: PetscReal levels; /* ILU(levels) */
512: PetscReal fill; /* expected fill; nonzeros in factored matrix/nonzeros in original matrix*/
513: PetscReal diagonal_fill; /* force diagonal to fill in if initially not filled */
514: PetscReal dt; /* drop tolerance */
515: PetscReal dtcol; /* tolerance for pivoting */
516: PetscReal dtcount; /* maximum nonzeros to be allowed per row */
517: PetscReal damping; /* scaling of identity added to matrix to prevent zero pivots */
518: PetscReal damp; /* if is 1.0 and factorization fails, damp until successful */
519: PetscReal zeropivot; /* pivot is called zero if less than this */
520: PetscReal pivotinblocks; /* for BAIJ and SBAIJ matrices pivot in factorization on blocks, default 1.0
521: factorization may be faster if do not pivot */
522: } MatILUInfo;
524: /*S
525: MatLUInfo - Data based into the matrix LU factorization routines
527: In Fortran these are simply double precision arrays of size MAT_LUINFO_SIZE
529: Notes: These are not usually directly used by users, instead use the PC type of LU
530: All entries are double precision.
532: Level: developer
534: .seealso: MatLUFactorSymbolic(), MatILUInfo, MatCholeskyInfo
536: S*/
537: typedef struct {
538: PetscReal fill; /* expected fill; nonzeros in factored matrix/nonzeros in original matrix */
539: PetscReal dtcol; /* tolerance for pivoting; pivot if off_diagonal*dtcol > diagonal */
540: PetscReal damping; /* scaling of identity added to matrix to prevent zero pivots */
541: PetscReal zeropivot; /* pivot is called zero if less than this */
542: PetscReal pivotinblocks; /* for BAIJ and SBAIJ matrices pivot in factorization on blocks, default 1.0
543: factorization may be faster if do not pivot */
544: } MatLUInfo;
546: /*S
547: MatCholeskyInfo - Data based into the matrix Cholesky factorization routines
549: In Fortran these are simply double precision arrays of size MAT_CHOLESKYINFO_SIZE
551: Notes: These are not usually directly used by users, instead use the PC type of Cholesky
552: All entries are double precision.
554: Level: developer
556: .seealso: MatCholeskyFactorSymbolic(), MatLUInfo, MatILUInfo
558: S*/
559: typedef struct {
560: PetscReal fill; /* expected fill; nonzeros in factored matrix/nonzeros in original matrix */
561: PetscReal damping; /* scaling of identity added to matrix to prevent zero pivots */
562: PetscReal pivotinblocks; /* for BAIJ and SBAIJ matrices pivot in factorization on blocks, default 1.0
563: factorization may be faster if do not pivot */
564: } MatCholeskyInfo;
566: EXTERN int MatLUFactor(Mat,IS,IS,MatLUInfo*);
567: EXTERN int MatILUFactor(Mat,IS,IS,MatILUInfo*);
568: EXTERN int MatLUFactorSymbolic(Mat,IS,IS,MatLUInfo*,Mat*);
569: EXTERN int MatILUFactorSymbolic(Mat,IS,IS,MatILUInfo*,Mat*);
570: EXTERN int MatICCFactorSymbolic(Mat,IS,PetscReal,int,Mat*);
571: EXTERN int MatICCFactor(Mat,IS,PetscReal,int);
572: EXTERN int MatLUFactorNumeric(Mat,Mat*);
573: EXTERN int MatILUDTFactor(Mat,MatILUInfo*,IS,IS,Mat *);
574: EXTERN int MatGetInertia(Mat,int*,int*,int*);
575: EXTERN int MatSolve(Mat,Vec,Vec);
576: EXTERN int MatForwardSolve(Mat,Vec,Vec);
577: EXTERN int MatBackwardSolve(Mat,Vec,Vec);
578: EXTERN int MatSolveAdd(Mat,Vec,Vec,Vec);
579: EXTERN int MatSolveTranspose(Mat,Vec,Vec);
580: EXTERN int MatSolveTransposeAdd(Mat,Vec,Vec,Vec);
581: EXTERN int MatSolves(Mat,Vecs,Vecs);
583: EXTERN int MatSetUnfactored(Mat);
585: /* MatSORType may be bitwise ORd together, so do not change the numbers */
586: /*E
587: MatSORType - What type of (S)SOR to perform
589: Level: beginner
591: May be bitwise ORd together
593: Any additions/changes here MUST also be made in include/finclude/petscmat.h
595: .seealso: MatRelax()
596: E*/
597: typedef enum {SOR_FORWARD_SWEEP=1,SOR_BACKWARD_SWEEP=2,SOR_SYMMETRIC_SWEEP=3,
598: SOR_LOCAL_FORWARD_SWEEP=4,SOR_LOCAL_BACKWARD_SWEEP=8,
599: SOR_LOCAL_SYMMETRIC_SWEEP=12,SOR_ZERO_INITIAL_GUESS=16,
600: SOR_EISENSTAT=32,SOR_APPLY_UPPER=64,SOR_APPLY_LOWER=128} MatSORType;
601: EXTERN int MatRelax(Mat,Vec,PetscReal,MatSORType,PetscReal,int,int,Vec);
603: /*
604: These routines are for efficiently computing Jacobians via finite differences.
605: */
607: /*E
608: MatColoringType - String with the name of a PETSc matrix coloring or the creation function
609: with an optional dynamic library name, for example
610: http://www.mcs.anl.gov/petsc/lib.a:coloringcreate()
612: Level: beginner
614: .seealso: MatGetColoring()
615: E*/
616: typedef char* MatColoringType;
617: #define MATCOLORING_NATURAL "natural"
618: #define MATCOLORING_SL "sl"
619: #define MATCOLORING_LF "lf"
620: #define MATCOLORING_ID "id"
622: EXTERN int MatGetColoring(Mat,MatColoringType,ISColoring*);
623: EXTERN int MatColoringRegister(char*,char*,char*,int(*)(Mat,MatColoringType,ISColoring *));
624: #if defined(PETSC_USE_DYNAMIC_LIBRARIES)
625: #define MatColoringRegisterDynamic(a,b,c,d) MatColoringRegister(a,b,c,0)
626: #else
627: #define MatColoringRegisterDynamic(a,b,c,d) MatColoringRegister(a,b,c,d)
628: #endif
629: EXTERN int MatColoringRegisterAll(char *);
630: extern PetscTruth MatColoringRegisterAllCalled;
631: EXTERN int MatColoringRegisterDestroy(void);
632: EXTERN int MatColoringPatch(Mat,int,int,int *,ISColoring*);
634: /*S
635: MatFDColoring - Object for computing a sparse Jacobian via finite differences
636: and coloring
638: Level: beginner
640: Concepts: coloring, sparse Jacobian, finite differences
642: .seealso: MatFDColoringCreate()
643: S*/
644: typedef struct _p_MatFDColoring *MatFDColoring;
646: EXTERN int MatFDColoringCreate(Mat,ISColoring,MatFDColoring *);
647: EXTERN int MatFDColoringDestroy(MatFDColoring);
648: EXTERN int MatFDColoringView(MatFDColoring,PetscViewer);
649: EXTERN int MatFDColoringSetFunction(MatFDColoring,int (*)(void),void*);
650: EXTERN int MatFDColoringSetParameters(MatFDColoring,PetscReal,PetscReal);
651: EXTERN int MatFDColoringSetFrequency(MatFDColoring,int);
652: EXTERN int MatFDColoringGetFrequency(MatFDColoring,int*);
653: EXTERN int MatFDColoringSetFromOptions(MatFDColoring);
654: EXTERN int MatFDColoringApply(Mat,MatFDColoring,Vec,MatStructure*,void *);
655: EXTERN int MatFDColoringApplyTS(Mat,MatFDColoring,PetscReal,Vec,MatStructure*,void *);
656: EXTERN int MatFDColoringSetRecompute(MatFDColoring);
657: EXTERN int MatFDColoringSetF(MatFDColoring,Vec);
658: EXTERN int MatFDColoringGetPerturbedColumns(MatFDColoring,int*,int**);
659: /*
660: These routines are for partitioning matrices: currently used only
661: for adjacency matrix, MatCreateMPIAdj().
662: */
664: /*S
665: MatPartitioning - Object for managing the partitioning of a matrix or graph
667: Level: beginner
669: Concepts: partitioning
671: .seealso: MatParitioningCreate(), MatPartitioningType
672: S*/
673: typedef struct _p_MatPartitioning *MatPartitioning;
675: /*E
676: MatPartitioningType - String with the name of a PETSc matrix partitioing or the creation function
677: with an optional dynamic library name, for example
678: http://www.mcs.anl.gov/petsc/lib.a:partitioningcreate()
680: Level: beginner
682: .seealso: MatPartitioingCreate(), MatPartitioning
683: E*/
684: typedef char* MatPartitioningType;
685: #define MAT_PARTITIONING_CURRENT "current"
686: #define MAT_PARTITIONING_PARMETIS "parmetis"
688: EXTERN int MatPartitioningCreate(MPI_Comm,MatPartitioning*);
689: EXTERN int MatPartitioningSetType(MatPartitioning,MatPartitioningType);
690: EXTERN int MatPartitioningSetAdjacency(MatPartitioning,Mat);
691: EXTERN int MatPartitioningSetVertexWeights(MatPartitioning,int*);
692: EXTERN int MatPartitioningApply(MatPartitioning,IS*);
693: EXTERN int MatPartitioningDestroy(MatPartitioning);
695: EXTERN int MatPartitioningRegister(char*,char*,char*,int(*)(MatPartitioning));
696: #if defined(PETSC_USE_DYNAMIC_LIBRARIES)
697: #define MatPartitioningRegisterDynamic(a,b,c,d) MatPartitioningRegister(a,b,c,0)
698: #else
699: #define MatPartitioningRegisterDynamic(a,b,c,d) MatPartitioningRegister(a,b,c,d)
700: #endif
702: EXTERN int MatPartitioningRegisterAll(char *);
703: extern PetscTruth MatPartitioningRegisterAllCalled;
704: EXTERN int MatPartitioningRegisterDestroy(void);
706: EXTERN int MatPartitioningView(MatPartitioning,PetscViewer);
707: EXTERN int MatPartitioningSetFromOptions(MatPartitioning);
708: EXTERN int MatPartitioningGetType(MatPartitioning,MatPartitioningType*);
710: EXTERN int MatPartitioningParmetisSetCoarseSequential(MatPartitioning);
712: /*
713: If you add entries here you must also add them to finclude/petscmat.h
714: */
715: typedef enum { MATOP_SET_VALUES=0,
716: MATOP_GET_ROW=1,
717: MATOP_RESTORE_ROW=2,
718: MATOP_MULT=3,
719: MATOP_MULT_ADD=4,
720: MATOP_MULT_TRANSPOSE=5,
721: MATOP_MULT_TRANSPOSE_ADD=6,
722: MATOP_SOLVE=7,
723: MATOP_SOLVE_ADD=8,
724: MATOP_SOLVE_TRANSPOSE=9,
725: MATOP_SOLVE_TRANSPOSE_ADD=10,
726: MATOP_LUFACTOR=11,
727: MATOP_CHOLESKYFACTOR=12,
728: MATOP_RELAX=13,
729: MATOP_TRANSPOSE=14,
730: MATOP_GETINFO=15,
731: MATOP_EQUAL=16,
732: MATOP_GET_DIAGONAL=17,
733: MATOP_DIAGONAL_SCALE=18,
734: MATOP_NORM=19,
735: MATOP_ASSEMBLY_BEGIN=20,
736: MATOP_ASSEMBLY_END=21,
737: MATOP_COMPRESS=22,
738: MATOP_SET_OPTION=23,
739: MATOP_ZERO_ENTRIES=24,
740: MATOP_ZERO_ROWS=25,
741: MATOP_LUFACTOR_SYMBOLIC=26,
742: MATOP_LUFACTOR_NUMERIC=27,
743: MATOP_CHOLESKY_FACTOR_SYMBOLIC=28,
744: MATOP_CHOLESKY_FACTOR_NUMERIC=29,
745: MATOP_SETUP_PREALLOCATION=30,
746: MATOP_ILUFACTOR_SYMBOLIC=31,
747: MATOP_ICCFACTOR_SYMBOLIC=32,
748: MATOP_GET_ARRAY=33,
749: MATOP_RESTORE_ARRAY=34,
750: MATOP_DUPLCIATE=35,
751: MATOP_FORWARD_SOLVE=36,
752: MATOP_BACKWARD_SOLVE=37,
753: MATOP_ILUFACTOR=38,
754: MATOP_ICCFACTOR=39,
755: MATOP_AXPY=40,
756: MATOP_GET_SUBMATRICES=41,
757: MATOP_INCREASE_OVERLAP=42,
758: MATOP_GET_VALUES=43,
759: MATOP_COPY=44,
760: MATOP_PRINT_HELP=45,
761: MATOP_SCALE=46,
762: MATOP_SHIFT=47,
763: MATOP_DIAGONAL_SHIFT=48,
764: MATOP_ILUDT_FACTOR=49,
765: MATOP_GET_BLOCK_SIZE=50,
766: MATOP_GET_ROW_IJ=51,
767: MATOP_RESTORE_ROW_IJ=52,
768: MATOP_GET_COLUMN_IJ=53,
769: MATOP_RESTORE_COLUMN_IJ=54,
770: MATOP_FDCOLORING_CREATE=55,
771: MATOP_COLORING_PATCH=56,
772: MATOP_SET_UNFACTORED=57,
773: MATOP_PERMUTE=58,
774: MATOP_SET_VALUES_BLOCKED=59,
775: MATOP_GET_SUBMATRIX=60,
776: MATOP_DESTROY=61,
777: MATOP_VIEW=62,
778: MATOP_GET_MAPS=63,
779: MATOP_USE_SCALED_FORM=64,
780: MATOP_SCALE_SYSTEM=65,
781: MATOP_UNSCALE_SYSTEM=66,
782: MATOP_SET_LOCAL_TO_GLOBAL_MAPPING=67,
783: MATOP_SET_VALUES_LOCAL=68,
784: MATOP_ZERO_ROWS_LOCAL=69,
785: MATOP_GET_ROW_MAX=70,
786: MATOP_CONVERT=71,
787: MATOP_SET_COLORING=72,
788: MATOP_SET_VALUES_ADIC=73,
789: MATOP_SET_VALUES_ADIFOR=74,
790: MATOP_FD_COLORING_APPLY=75,
791: MATOP_SET_FROM_OPTIONS=76,
792: MATOP_MULT_CONSTRAINED=77,
793: MATOP_MULT_TRANSPOSE_CONSTRAINED=78,
794: MATOP_ILU_FACTOR_SYMBOLIC_CONSTRAINED=79,
795: MATOP_PERMUTE_SPARSIFY=80,
796: MATOP_MULT_MULTIPLE=81,
797: MATOP_SOLVE_MULTIPLE=82
798: } MatOperation;
799: EXTERN int MatHasOperation(Mat,MatOperation,PetscTruth*);
800: EXTERN int MatShellSetOperation(Mat,MatOperation,void(*)(void));
801: EXTERN int MatShellGetOperation(Mat,MatOperation,void(**)(void));
802: EXTERN int MatShellSetContext(Mat,void*);
804: /*
805: Codes for matrices stored on disk. By default they are
806: stored in a universal format. By changing the format with
807: PetscViewerSetFormat(viewer,PETSC_VIEWER_BINARY_NATIVE); the matrices will
808: be stored in a way natural for the matrix, for example dense matrices
809: would be stored as dense. Matrices stored this way may only be
810: read into matrices of the same time.
811: */
812: #define MATRIX_BINARY_FORMAT_DENSE -1
814: /*
815: New matrix classes not yet distributed
816: */
817: /*
818: MatAIJIndices is a data structure for storing the nonzero location information
819: for sparse matrices. Several matrices with identical nonzero structure can share
820: the same MatAIJIndices.
821: */
822: typedef struct _p_MatAIJIndices* MatAIJIndices;
824: EXTERN int MatCreateAIJIndices(int,int,int*,int*,PetscTruth,MatAIJIndices*);
825: EXTERN int MatCreateAIJIndicesEmpty(int,int,int*,PetscTruth,MatAIJIndices*);
826: EXTERN int MatAttachAIJIndices(MatAIJIndices,MatAIJIndices*);
827: EXTERN int MatDestroyAIJIndices(MatAIJIndices);
828: EXTERN int MatCopyAIJIndices(MatAIJIndices,MatAIJIndices*);
829: EXTERN int MatValidateAIJIndices(int,MatAIJIndices);
830: EXTERN int MatShiftAIJIndices(MatAIJIndices);
831: EXTERN int MatShrinkAIJIndices(MatAIJIndices);
832: EXTERN int MatTransposeAIJIndices(MatAIJIndices,MatAIJIndices*);
834: EXTERN int MatCreateSeqCSN(MPI_Comm,int,int,int*,int,Mat*);
835: EXTERN int MatCreateSeqCSN_Single(MPI_Comm,int,int,int*,int,Mat*);
836: EXTERN int MatCreateSeqCSNWithPrecision(MPI_Comm,int,int,int*,int,PetscScalarPrecision,Mat*);
838: EXTERN int MatCreateSeqCSNIndices(MPI_Comm,MatAIJIndices,int,Mat *);
839: EXTERN int MatCreateSeqCSNIndices_Single(MPI_Comm,MatAIJIndices,int,Mat *);
840: EXTERN int MatCreateSeqCSNIndicesWithPrecision(MPI_Comm,MatAIJIndices,int,PetscScalarPrecision,Mat *);
842: EXTERN int MatMPIBAIJSetHashTableFactor(Mat,PetscReal);
843: EXTERN int MatSeqAIJGetInodeSizes(Mat,int *,int *[],int *);
844: EXTERN int MatMPIRowbsGetColor(Mat,ISColoring *);
846: /*S
847: MatNullSpace - Object that removes a null space from a vector, i.e.
848: orthogonalizes the vector to a subsapce
850: Level: advanced
852: Concepts: matrix; linear operator, null space
854: Users manual sections:
855: . Section 4.15 Solving Singular Systems
857: .seealso: MatNullSpaceCreate()
858: S*/
859: typedef struct _p_MatNullSpace* MatNullSpace;
861: EXTERN int MatNullSpaceCreate(MPI_Comm,int,int,Vec *,MatNullSpace*);
862: EXTERN int MatNullSpaceDestroy(MatNullSpace);
863: EXTERN int MatNullSpaceRemove(MatNullSpace,Vec,Vec*);
864: EXTERN int MatNullSpaceAttach(Mat,MatNullSpace);
865: EXTERN int MatNullSpaceTest(MatNullSpace,Mat);
867: EXTERN int MatReorderingSeqSBAIJ(Mat A,IS isp);
868: EXTERN int MatMPISBAIJSetHashTableFactor(Mat,PetscReal);
869: EXTERN int MatSeqSBAIJSetColumnIndices(Mat,int *);
872: EXTERN int MatCreateMAIJ(Mat,int,Mat*);
873: EXTERN int MatMAIJRedimension(Mat,int,Mat*);
874: EXTERN int MatMAIJGetAIJ(Mat,Mat*);
876: EXTERN int MatMPIAdjSetValues(Mat,int*,int*,int*);
878: EXTERN int MatComputeExplicitOperator(Mat,Mat*);
880: EXTERN int MatESISetType(Mat,char*);
881: EXTERN int MatESISetFromOptions(Mat);
883: EXTERN int MatDiagonalScaleLocal(Mat,Vec);
885: EXTERN int PetscViewerMathematicaPutMatrix(PetscViewer, int, int, PetscReal *);
886: EXTERN int PetscViewerMathematicaPutCSRMatrix(PetscViewer, int, int, int *, int *, PetscReal *);
888: EXTERN int MatUseSuperLU_DIST_MPIAIJ(Mat);
889: EXTERN int MatUseSpooles_SeqAIJ(Mat);
890: EXTERN int MatUseUMFPACK_SeqAIJ(Mat);
891: EXTERN int MatUseSuperLU_SeqAIJ(Mat);
892: EXTERN int MatUseEssl_SeqAIJ(Mat);
893: EXTERN int MatUseLUSOL_SeqAIJ(Mat);
894: EXTERN int MatUseMatlab_SeqAIJ(Mat);
895: EXTERN int MatUseDXML_SeqAIJ(Mat);
896: EXTERN int MatUseSuperLU_DIST_MPIAIJ(Mat);
897: EXTERN int MatUseSpooles_MPIAIJ(Mat);
898: EXTERN int MatUseSpooles_SeqSBAIJ(Mat);
899: extern int MatUseSpooles_MPISBAIJ(Mat);
901: #endif