Actual source code: petscmat.h

      1: /*
      2:      Include file for the matrix component of PETSc
      3: */
      4: #ifndef __PETSCMAT_H
     6:  #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 MATMAIJ            "maij"
     33: #define MATIS              "is"
     34: #define MATMPIROWBS        "mpirowbs"
     35: #define MATSEQAIJ          "seqaij"
     36: #define MATMPIAIJ          "mpiaij"
     37: #define MATAIJ             "aij"
     38: #define MATSHELL           "shell"
     39: #define MATSEQBDIAG        "seqbdiag"
     40: #define MATMPIBDIAG        "mpibdiag"
     41: #define MATBDIAG           "bdiag"
     42: #define MATSEQDENSE        "seqdense"
     43: #define MATMPIDENSE        "mpidense"
     44: #define MATDENSE           "dense"
     45: #define MATSEQBAIJ         "seqbaij"
     46: #define MATMPIBAIJ         "mpibaij"
     47: #define MATBAIJ            "baij"
     48: #define MATMPIADJ          "mpiadj"
     49: #define MATSEQSBAIJ        "seqsbaij"
     50: #define MATMPISBAIJ        "mpisbaij"
     51: #define MATSBAIJ           "sbaij"
     52: #define MATDAAD            "daad"
     53: #define MATMFFD            "mffd"
     54: #define MATNORMAL          "normal"
     55: #define MATSEQAIJSPOOLES   "seqaijspooles"
     56: #define MATMPIAIJSPOOLES   "mpiaijspooles"
     57: #define MATSEQSBAIJSPOOLES "seqsbaijspooles"
     58: #define MATMPISBAIJSPOOLES "mpisbaijspooles"
     59: #define MATAIJSPOOLES      "aijspooles"
     60: #define MATSBAIJSPOOLES    "sbaijspooles"
     61: #define MATSUPERLU         "superlu"
     62: #define MATSUPERLU_DIST    "superlu_dist"
     63: #define MATUMFPACK         "umfpack"
     64: #define MATESSL            "essl"
     65: #define MATLUSOL           "lusol"
     66: #define MATAIJMUMPS        "aijmumps"
     67: #define MATSBAIJMUMPS      "sbaijmumps"
     68: #define MATDSCPACK         "dscpack"
     69: #define MATMATLAB          "matlab"
     70: #define MatType char*

     72: /* Logging support */
     73: #define    MAT_FILE_COOKIE 1211216    /* used to indicate matrices in binary files */

     87: EXTERN PetscErrorCode MatInitializePackage(char *);

     89: EXTERN PetscErrorCode MatCreate(MPI_Comm,PetscInt,PetscInt,PetscInt,PetscInt,Mat*);
     90: EXTERN PetscErrorCode MatSetType(Mat,const MatType);
     91: EXTERN PetscErrorCode MatSetFromOptions(Mat);
     92: EXTERN PetscErrorCode MatSetUpPreallocation(Mat);
     93: EXTERN PetscErrorCode MatRegisterAll(const char[]);
     94: EXTERN PetscErrorCode MatRegister(const char[],const char[],const char[],PetscErrorCode(*)(Mat));

     96: /*MC
     97:    MatRegisterDynamic - Adds a new matrix type

     99:    Synopsis:
    100:    PetscErrorCode MatRegisterDynamic(char *name,char *path,char *name_create,PetscErrorCode (*routine_create)(Mat))

    102:    Not Collective

    104:    Input Parameters:
    105: +  name - name of a new user-defined matrix type
    106: .  path - path (either absolute or relative) the library containing this solver
    107: .  name_create - name of routine to create method context
    108: -  routine_create - routine to create method context

    110:    Notes:
    111:    MatRegisterDynamic() may be called multiple times to add several user-defined solvers.

    113:    If dynamic libraries are used, then the fourth input argument (routine_create)
    114:    is ignored.

    116:    Sample usage:
    117: .vb
    118:    MatRegisterDynamic("my_mat",/home/username/my_lib/lib/libO/solaris/mylib.a,
    119:                "MyMatCreate",MyMatCreate);
    120: .ve

    122:    Then, your solver can be chosen with the procedural interface via
    123: $     MatSetType(Mat,"my_mat")
    124:    or at runtime via the option
    125: $     -mat_type my_mat

    127:    Level: advanced

    129:    Notes: ${PETSC_ARCH} and ${BOPT} occuring in pathname will be replaced with appropriate values.
    130:          If your function is not being put into a shared library then use VecRegister() instead

    132: .keywords: Mat, register

    134: .seealso: MatRegisterAll(), MatRegisterDestroy()

    136: M*/
    137: #if defined(PETSC_USE_DYNAMIC_LIBRARIES)
    138: #define MatRegisterDynamic(a,b,c,d) MatRegister(a,b,c,0)
    139: #else
    140: #define MatRegisterDynamic(a,b,c,d) MatRegister(a,b,c,d)
    141: #endif

    146: EXTERN PetscErrorCode MatCreateSeqDense(MPI_Comm,PetscInt,PetscInt,PetscScalar[],Mat*);
    147: EXTERN PetscErrorCode MatCreateMPIDense(MPI_Comm,PetscInt,PetscInt,PetscInt,PetscInt,PetscScalar[],Mat*);
    148: EXTERN PetscErrorCode MatCreateSeqAIJ(MPI_Comm,PetscInt,PetscInt,PetscInt,const PetscInt[],Mat*);
    149: EXTERN PetscErrorCode MatCreateMPIAIJ(MPI_Comm,PetscInt,PetscInt,PetscInt,PetscInt,PetscInt,const PetscInt[],PetscInt,const PetscInt[],Mat*);
    150: EXTERN PetscErrorCode MatCreateMPIRowbs(MPI_Comm,PetscInt,PetscInt,PetscInt,const PetscInt[],Mat*);
    151: EXTERN PetscErrorCode MatCreateSeqBDiag(MPI_Comm,PetscInt,PetscInt,PetscInt,PetscInt,const PetscInt[],PetscScalar*[],Mat*);
    152: EXTERN PetscErrorCode MatCreateMPIBDiag(MPI_Comm,PetscInt,PetscInt,PetscInt,PetscInt,PetscInt,const PetscInt[],PetscScalar*[],Mat*);
    153: EXTERN PetscErrorCode MatCreateSeqBAIJ(MPI_Comm,PetscInt,PetscInt,PetscInt,PetscInt,const PetscInt[],Mat*);
    154: EXTERN PetscErrorCode MatCreateMPIBAIJ(MPI_Comm,PetscInt,PetscInt,PetscInt,PetscInt,PetscInt,PetscInt,const PetscInt[],PetscInt,const PetscInt[],Mat*);
    155: EXTERN PetscErrorCode MatCreateMPIAdj(MPI_Comm,PetscInt,PetscInt,PetscInt[],PetscInt[],PetscInt[],Mat*);
    156: EXTERN PetscErrorCode MatCreateSeqSBAIJ(MPI_Comm,PetscInt,PetscInt,PetscInt,PetscInt,const PetscInt[],Mat*);
    157: EXTERN PetscErrorCode MatCreateMPISBAIJ(MPI_Comm,PetscInt,PetscInt,PetscInt,PetscInt,PetscInt,PetscInt,const PetscInt[],PetscInt,const PetscInt[],Mat*);
    158: EXTERN PetscErrorCode MatCreateShell(MPI_Comm,PetscInt,PetscInt,PetscInt,PetscInt,void *,Mat*);
    159: EXTERN PetscErrorCode MatCreateAdic(MPI_Comm,PetscInt,PetscInt,PetscInt,PetscInt,PetscInt,void (*)(void),Mat*);
    160: EXTERN PetscErrorCode MatCreateNormal(Mat,Mat*);
    161: EXTERN PetscErrorCode MatDestroy(Mat);

    163: EXTERN PetscErrorCode MatPrintHelp(Mat);
    164: EXTERN PetscErrorCode MatGetPetscMaps(Mat,PetscMap*,PetscMap*);

    166: /* ------------------------------------------------------------*/
    167: EXTERN PetscErrorCode MatSetValues(Mat,PetscInt,const PetscInt[],PetscInt,const PetscInt[],const PetscScalar[],InsertMode);
    168: EXTERN PetscErrorCode MatSetValuesBlocked(Mat,PetscInt,const PetscInt[],PetscInt,const PetscInt[],const PetscScalar[],InsertMode);

    170: /*S
    171:      MatStencil - Data structure (C struct) for storing information about a single row or
    172:         column of a matrix as index on an associated grid.

    174:    Level: beginner

    176:   Concepts: matrix; linear operator

    178: .seealso:  MatSetValuesStencil(), MatSetStencil(), MatSetValuesBlockStencil()
    179: S*/
    180: typedef struct {
    181:   PetscInt k,j,i,c;
    182: } MatStencil;

    184: EXTERN PetscErrorCode MatSetValuesStencil(Mat,PetscInt,const MatStencil[],PetscInt,const MatStencil[],const PetscScalar[],InsertMode);
    185: EXTERN PetscErrorCode MatSetValuesBlockedStencil(Mat,PetscInt,const MatStencil[],PetscInt,const MatStencil[],const PetscScalar[],InsertMode);
    186: EXTERN PetscErrorCode MatSetStencil(Mat,PetscInt,const PetscInt[],const PetscInt[],PetscInt);

    188: EXTERN PetscErrorCode MatSetColoring(Mat,ISColoring);
    189: EXTERN PetscErrorCode MatSetValuesAdic(Mat,void*);
    190: EXTERN PetscErrorCode MatSetValuesAdifor(Mat,PetscInt,void*);

    192: /*E
    193:     MatAssemblyType - Indicates if the matrix is now to be used, or if you plan
    194:      to continue to add values to it

    196:     Level: beginner

    198: .seealso: MatAssemblyBegin(), MatAssemblyEnd()
    199: E*/
    200: typedef enum {MAT_FLUSH_ASSEMBLY=1,MAT_FINAL_ASSEMBLY=0} MatAssemblyType;
    201: EXTERN PetscErrorCode MatAssemblyBegin(Mat,MatAssemblyType);
    202: EXTERN PetscErrorCode MatAssemblyEnd(Mat,MatAssemblyType);
    203: EXTERN PetscErrorCode MatAssembled(Mat,PetscTruth*);

    208: /*MC
    209:    MatSetValue - Set a single entry into a matrix.

    211:    Synopsis:
    212:    PetscErrorCode MatSetValue(Mat m,PetscInt row,PetscInt col,PetscScalar value,InsertMode mode);

    214:    Not collective

    216:    Input Parameters:
    217: +  m - the matrix
    218: .  row - the row location of the entry
    219: .  col - the column location of the entry
    220: .  value - the value to insert
    221: -  mode - either INSERT_VALUES or ADD_VALUES

    223:    Notes:
    224:    For efficiency one should use MatSetValues() and set several or many
    225:    values simultaneously if possible.

    227:    Level: beginner

    229: .seealso: MatSetValues(), MatSetValueLocal()
    230: M*/
    231: #define MatSetValue(v,i,j,va,mode) \
    232:   (MatSetValue_Row = i,MatSetValue_Column = j,MatSetValue_Value = va, \
    233:    MatSetValues(v,1,&MatSetValue_Row,1,&MatSetValue_Column,&MatSetValue_Value,mode))

    235: #define MatGetValue(v,i,j,va) \
    236:   (MatSetValue_Row = i,MatSetValue_Column = j,\
    237:    MatGetValues(v,1,&MatSetValue_Row,1,&MatSetValue_Column,&va))

    239: #define MatSetValueLocal(v,i,j,va,mode) \
    240:   (MatSetValue_Row = i,MatSetValue_Column = j,MatSetValue_Value = va, \
    241:    MatSetValuesLocal(v,1,&MatSetValue_Row,1,&MatSetValue_Column,&MatSetValue_Value,mode))

    243: /*E
    244:     MatOption - Options that may be set for a matrix and its behavior or storage

    246:     Level: beginner

    248:    Any additions/changes here MUST also be made in include/finclude/petscmat.h

    250: .seealso: MatSetOption()
    251: E*/
    252: typedef enum {MAT_ROW_ORIENTED=1,MAT_COLUMN_ORIENTED=2,MAT_ROWS_SORTED=4,
    253:               MAT_COLUMNS_SORTED=8,MAT_NO_NEW_NONZERO_LOCATIONS=16,
    254:               MAT_YES_NEW_NONZERO_LOCATIONS=32,MAT_SYMMETRIC=64,
    255:               MAT_STRUCTURALLY_SYMMETRIC=65,MAT_NO_NEW_DIAGONALS=66,
    256:               MAT_YES_NEW_DIAGONALS=67,MAT_INODE_LIMIT_1=68,MAT_INODE_LIMIT_2=69,
    257:               MAT_INODE_LIMIT_3=70,MAT_INODE_LIMIT_4=71,MAT_INODE_LIMIT_5=72,
    258:               MAT_IGNORE_OFF_PROC_ENTRIES=73,MAT_ROWS_UNSORTED=74,
    259:               MAT_COLUMNS_UNSORTED=75,MAT_NEW_NONZERO_LOCATION_ERR=76,
    260:               MAT_NEW_NONZERO_ALLOCATION_ERR=77,MAT_USE_HASH_TABLE=78,
    261:               MAT_KEEP_ZEROED_ROWS=79,MAT_IGNORE_ZERO_ENTRIES=80,MAT_USE_INODES=81,
    262:               MAT_DO_NOT_USE_INODES=82,MAT_NOT_SYMMETRIC=83,MAT_HERMITIAN=84,
    263:               MAT_NOT_STRUCTURALLY_SYMMETRIC=85,MAT_NOT_HERMITIAN=86,
    264:               MAT_SYMMETRY_ETERNAL=87,MAT_NOT_SYMMETRY_ETERNAL=88} MatOption;
    265: EXTERN PetscErrorCode MatSetOption(Mat,MatOption);
    266: EXTERN PetscErrorCode MatGetType(Mat,MatType*);

    268: EXTERN PetscErrorCode MatGetValues(Mat,PetscInt,const PetscInt[],PetscInt,const PetscInt[],PetscScalar[]);
    269: EXTERN PetscErrorCode MatGetRow(Mat,PetscInt,PetscInt *,const PetscInt *[],const PetscScalar*[]);
    270: EXTERN PetscErrorCode MatRestoreRow(Mat,PetscInt,PetscInt *,const PetscInt *[],const PetscScalar*[]);
    271: EXTERN PetscErrorCode MatGetColumn(Mat,PetscInt,PetscInt *,const PetscInt *[],const PetscScalar*[]);
    272: EXTERN PetscErrorCode MatRestoreColumn(Mat,PetscInt,PetscInt *,const PetscInt *[],const PetscScalar*[]);
    273: EXTERN PetscErrorCode MatGetColumnVector(Mat,Vec,PetscInt);
    274: EXTERN PetscErrorCode MatGetArray(Mat,PetscScalar *[]);
    275: EXTERN PetscErrorCode MatRestoreArray(Mat,PetscScalar *[]);
    276: EXTERN PetscErrorCode MatGetBlockSize(Mat,PetscInt *);
    277: EXTERN PetscErrorCode MatSetBlockSize(Mat,PetscInt);

    279: EXTERN PetscErrorCode MatMult(Mat,Vec,Vec);
    280: EXTERN PetscErrorCode MatMultAdd(Mat,Vec,Vec,Vec);
    281: EXTERN PetscErrorCode MatMultTranspose(Mat,Vec,Vec);
    282: EXTERN PetscErrorCode MatIsTranspose(Mat,Mat,PetscReal,PetscTruth*);
    283: EXTERN PetscErrorCode MatMultTransposeAdd(Mat,Vec,Vec,Vec);
    284: EXTERN PetscErrorCode MatMultConstrained(Mat,Vec,Vec);
    285: EXTERN PetscErrorCode MatMultTransposeConstrained(Mat,Vec,Vec);

    287: /*E
    288:     MatDuplicateOption - Indicates if a duplicated sparse matrix should have
    289:   its numerical values copied over or just its nonzero structure.

    291:     Level: beginner

    293:    Any additions/changes here MUST also be made in include/finclude/petscmat.h

    295: .seealso: MatDuplicate()
    296: E*/
    297: typedef enum {MAT_DO_NOT_COPY_VALUES,MAT_COPY_VALUES} MatDuplicateOption;

    299: EXTERN PetscErrorCode MatConvertRegister(const char[],const char[],const char[],PetscErrorCode (*)(Mat,MatType,Mat*));
    300: #if defined(PETSC_USE_DYNAMIC_LIBRARIES)
    301: #define MatConvertRegisterDynamic(a,b,c,d) MatConvertRegister(a,b,c,0)
    302: #else
    303: #define MatConvertRegisterDynamic(a,b,c,d) MatConvertRegister(a,b,c,d)
    304: #endif
    305: EXTERN PetscErrorCode        MatConvertRegisterAll(const char[]);
    306: EXTERN PetscErrorCode        MatConvertRegisterDestroy(void);
    309: EXTERN PetscErrorCode        MatConvert(Mat,const MatType,Mat*);
    310: EXTERN PetscErrorCode        MatDuplicate(Mat,MatDuplicateOption,Mat*);

    312: /*E
    313:     MatStructure - Indicates if the matrix has the same nonzero structure

    315:     Level: beginner

    317:    Any additions/changes here MUST also be made in include/finclude/petscmat.h

    319: .seealso: MatCopy(), KSPSetOperators(), PCSetOperators()
    320: E*/
    321: typedef enum {SAME_NONZERO_PATTERN,DIFFERENT_NONZERO_PATTERN,SAME_PRECONDITIONER,SUBSET_NONZERO_PATTERN} MatStructure;

    323: EXTERN PetscErrorCode MatCopy(Mat,Mat,MatStructure);
    324: EXTERN PetscErrorCode MatView(Mat,PetscViewer);
    325: EXTERN PetscErrorCode MatIsSymmetric(Mat,PetscReal,PetscTruth*);
    326: EXTERN PetscErrorCode MatIsSymmetricKnown(Mat,PetscTruth*,PetscTruth*);
    327: EXTERN PetscErrorCode MatIsHermitianKnown(Mat,PetscTruth*,PetscTruth*);
    328: EXTERN PetscErrorCode MatLoad(PetscViewer,const MatType,Mat*);

    330: EXTERN PetscErrorCode MatGetRowIJ(Mat,PetscInt,PetscTruth,PetscInt*,PetscInt *[],PetscInt *[],PetscTruth *);
    331: EXTERN PetscErrorCode MatRestoreRowIJ(Mat,PetscInt,PetscTruth,PetscInt *,PetscInt *[],PetscInt *[],PetscTruth *);
    332: EXTERN PetscErrorCode MatGetColumnIJ(Mat,PetscInt,PetscTruth,PetscInt*,PetscInt *[],PetscInt *[],PetscTruth *);
    333: EXTERN PetscErrorCode MatRestoreColumnIJ(Mat,PetscInt,PetscTruth,PetscInt *,PetscInt *[],PetscInt *[],PetscTruth *);

    335: /*S
    336:      MatInfo - Context of matrix information, used with MatGetInfo()

    338:    In Fortran this is simply a double precision array of dimension MAT_INFO_SIZE

    340:    Level: intermediate

    342:   Concepts: matrix^nonzero information

    344: .seealso:  MatGetInfo(), MatInfoType
    345: S*/
    346: typedef struct {
    347:   PetscLogDouble rows_global,columns_global;         /* number of global rows and columns */
    348:   PetscLogDouble rows_local,columns_local;           /* number of local rows and columns */
    349:   PetscLogDouble block_size;                         /* block size */
    350:   PetscLogDouble nz_allocated,nz_used,nz_unneeded;   /* number of nonzeros */
    351:   PetscLogDouble memory;                             /* memory allocated */
    352:   PetscLogDouble assemblies;                         /* number of matrix assemblies called */
    353:   PetscLogDouble mallocs;                            /* number of mallocs during MatSetValues() */
    354:   PetscLogDouble fill_ratio_given,fill_ratio_needed; /* fill ratio for LU/ILU */
    355:   PetscLogDouble factor_mallocs;                     /* number of mallocs during factorization */
    356: } MatInfo;

    358: /*E
    359:     MatInfoType - Indicates if you want information about the local part of the matrix,
    360:      the entire parallel matrix or the maximum over all the local parts.

    362:     Level: beginner

    364:    Any additions/changes here MUST also be made in include/finclude/petscmat.h

    366: .seealso: MatGetInfo(), MatInfo
    367: E*/
    368: typedef enum {MAT_LOCAL=1,MAT_GLOBAL_MAX=2,MAT_GLOBAL_SUM=3} MatInfoType;
    369: EXTERN PetscErrorCode MatGetInfo(Mat,MatInfoType,MatInfo*);
    370: EXTERN PetscErrorCode MatValid(Mat,PetscTruth*);
    371: EXTERN PetscErrorCode MatGetDiagonal(Mat,Vec);
    372: EXTERN PetscErrorCode MatGetRowMax(Mat,Vec);
    373: EXTERN PetscErrorCode MatTranspose(Mat,Mat*);
    374: EXTERN PetscErrorCode MatPermute(Mat,IS,IS,Mat *);
    375: EXTERN PetscErrorCode MatPermuteSparsify(Mat,PetscInt,PetscReal,PetscReal,IS,IS,Mat *);
    376: EXTERN PetscErrorCode MatDiagonalScale(Mat,Vec,Vec);
    377: EXTERN PetscErrorCode MatDiagonalSet(Mat,Vec,InsertMode);
    378: EXTERN PetscErrorCode MatEqual(Mat,Mat,PetscTruth*);

    380: EXTERN PetscErrorCode MatNorm(Mat,NormType,PetscReal *);
    381: EXTERN PetscErrorCode MatZeroEntries(Mat);
    382: EXTERN PetscErrorCode MatZeroRows(Mat,IS,const PetscScalar*);
    383: EXTERN PetscErrorCode MatZeroColumns(Mat,IS,const PetscScalar*);

    385: EXTERN PetscErrorCode MatUseScaledForm(Mat,PetscTruth);
    386: EXTERN PetscErrorCode MatScaleSystem(Mat,Vec,Vec);
    387: EXTERN PetscErrorCode MatUnScaleSystem(Mat,Vec,Vec);

    389: EXTERN PetscErrorCode MatGetSize(Mat,PetscInt*,PetscInt*);
    390: EXTERN PetscErrorCode MatGetLocalSize(Mat,PetscInt*,PetscInt*);
    391: EXTERN PetscErrorCode MatGetOwnershipRange(Mat,PetscInt*,PetscInt*);

    393: /*E
    394:     MatReuse - Indicates if matrices obtained from a previous call to MatGetSubMatrices()
    395:      or MatGetSubMatrix() are to be reused to store the new matrix values.

    397:     Level: beginner

    399:    Any additions/changes here MUST also be made in include/finclude/petscmat.h

    401: .seealso: MatGetSubMatrices(), MatGetSubMatrix(), MatDestroyMatrices()
    402: E*/
    403: typedef enum {MAT_INITIAL_MATRIX,MAT_REUSE_MATRIX} MatReuse;
    404: EXTERN PetscErrorCode MatGetSubMatrices(Mat,PetscInt,const IS[],const IS[],MatReuse,Mat *[]);
    405: EXTERN PetscErrorCode MatDestroyMatrices(PetscInt,Mat *[]);
    406: EXTERN PetscErrorCode MatGetSubMatrix(Mat,IS,IS,PetscInt,MatReuse,Mat *);
    407: EXTERN PetscErrorCode MatMerge(MPI_Comm,Mat,PetscInt,MatReuse,Mat*);
    408: EXTERN PetscErrorCode MatMerge_SeqsToMPI(MPI_Comm,Mat,PetscInt,PetscInt,MatReuse,Mat*);
    409: EXTERN PetscErrorCode MatMerge_SeqsToMPISymbolic(MPI_Comm,Mat,PetscInt,PetscInt,Mat*);
    410: EXTERN PetscErrorCode MatMerge_SeqsToMPINumeric(Mat,Mat);
    411: EXTERN PetscErrorCode MatDestroy_MPIAIJ_SeqsToMPI(Mat);
    412: EXTERN PetscErrorCode MatGetLocalMat(Mat,MatReuse,Mat*);
    413: EXTERN PetscErrorCode MatGetLocalMatCondensed(Mat,MatReuse,IS*,IS*,Mat*);
    414: EXTERN PetscErrorCode MatGetBrowsOfAcols(Mat,Mat,MatReuse,IS*,IS*,PetscInt*,Mat*);
    415: EXTERN PetscErrorCode MatGetBrowsOfAoCols(Mat,Mat,MatReuse,PetscInt**,PetscScalar**,Mat*);

    417: EXTERN PetscErrorCode MatIncreaseOverlap(Mat,PetscInt,IS[],PetscInt);

    419: EXTERN PetscErrorCode MatMatMult(Mat,Mat,MatReuse,PetscReal,Mat*);
    420: EXTERN PetscErrorCode MatMatMultSymbolic(Mat,Mat,PetscReal,Mat*);
    421: EXTERN PetscErrorCode MatMatMultNumeric(Mat,Mat,Mat);

    423: EXTERN PetscErrorCode MatPtAP(Mat,Mat,MatReuse,PetscReal,Mat*);
    424: EXTERN PetscErrorCode MatPtAPSymbolic(Mat,Mat,PetscReal,Mat*);
    425: EXTERN PetscErrorCode MatPtAPNumeric(Mat,Mat,Mat);

    427: EXTERN PetscErrorCode MatMatMultTranspose(Mat,Mat,MatReuse,PetscReal,Mat*);
    428: EXTERN PetscErrorCode MatMatMultTransposeSymbolic(Mat,Mat,PetscReal,Mat*);
    429: EXTERN PetscErrorCode MatMatMultTransposeNumeric(Mat,Mat,Mat);

    431: EXTERN PetscErrorCode MatAXPY(const PetscScalar *,Mat,Mat,MatStructure);
    432: EXTERN PetscErrorCode MatAYPX(const PetscScalar *,Mat,Mat);
    433: EXTERN PetscErrorCode MatCompress(Mat);

    435: EXTERN PetscErrorCode MatScale(const PetscScalar *,Mat);
    436: EXTERN PetscErrorCode MatShift(const PetscScalar *,Mat);

    438: EXTERN PetscErrorCode MatSetLocalToGlobalMapping(Mat,ISLocalToGlobalMapping);
    439: EXTERN PetscErrorCode MatSetLocalToGlobalMappingBlock(Mat,ISLocalToGlobalMapping);
    440: EXTERN PetscErrorCode MatZeroRowsLocal(Mat,IS,const PetscScalar*);
    441: EXTERN PetscErrorCode MatSetValuesLocal(Mat,PetscInt,const PetscInt[],PetscInt,const PetscInt[],const PetscScalar[],InsertMode);
    442: EXTERN PetscErrorCode MatSetValuesBlockedLocal(Mat,PetscInt,const PetscInt[],PetscInt,const PetscInt[],const PetscScalar[],InsertMode);

    444: EXTERN PetscErrorCode MatStashSetInitialSize(Mat,PetscInt,PetscInt);
    445: EXTERN PetscErrorCode MatStashGetInfo(Mat,PetscInt*,PetscInt*,PetscInt*,PetscInt*);

    447: EXTERN PetscErrorCode MatInterpolateAdd(Mat,Vec,Vec,Vec);
    448: EXTERN PetscErrorCode MatInterpolate(Mat,Vec,Vec);
    449: EXTERN PetscErrorCode MatRestrict(Mat,Vec,Vec);
    450: EXTERN PetscErrorCode MatGetVecs(Mat,Vec*,Vec*);

    452: /*MC
    453:    MatPreallocInitialize - Begins the block of code that will count the number of nonzeros per
    454:        row in a matrix providing the data that one can use to correctly preallocate the matrix.

    456:    Synopsis:
    457:    PetscErrorCode MatPreallocateInitialize(MPI_Comm comm, PetscInt nrows, PetscInt ncols, PetscInt *dnz, PetscInt *onz)

    459:    Collective on MPI_Comm

    461:    Input Parameters:
    462: +  comm - the communicator that will share the eventually allocated matrix
    463: .  nrows - the number of rows in the matrix
    464: -  ncols - the number of columns in the matrix

    466:    Output Parameters:
    467: +  dnz - the array that will be passed to the matrix preallocation routines
    468: -  ozn - the other array passed to the matrix preallocation routines

    471:    Level: intermediate

    473:    Notes:
    474:    See the chapter in the users manual on performance for more details

    476:    Do not malloc or free dnz and onz, that is handled internally by these routines

    478:    Use MatPreallocateInitializeSymmetric() for symmetric matrices (MPISBAIJ matrices)

    480:   Concepts: preallocation^Matrix

    482: .seealso: MatPreallocateFinalize(), MatPreallocateSet(), MatPreallocateSymmetricSet(), MatPreallocateSetLocal(),
    483:           MatPreallocateInitializeSymmetric(), MatPreallocateSymmetricSetLocal()
    484: M*/
    485: #define MatPreallocateInitialize(comm,nrows,ncols,dnz,onz) 0; \
    486: { \
    487:   PetscErrorCode _4_ierr; PetscInt __tmp = (nrows),__ctmp = (ncols),__rstart,__start,__end; \
    488:   _4_PetscMalloc(2*__tmp*sizeof(PetscInt),&dnz);CHKERRQ(_4_ierr);onz = dnz + __tmp;\
    489:   _4_PetscMemzero(dnz,2*__tmp*sizeof(PetscInt));CHKERRQ(_4_ierr);\
    490:   _4_MPI_Scan(&__ctmp,&__end,1,MPIU_INT,MPI_SUM,comm);CHKERRQ(_4_ierr); __start = __end - __ctmp;\
    491:   _4_MPI_Scan(&__tmp,&__rstart,1,MPIU_INT,MPI_SUM,comm);CHKERRQ(_4_ierr); __rstart = __rstart - __tmp;

    493: /*MC
    494:    MatPreallocSymmetricInitialize - Begins the block of code that will count the number of nonzeros per
    495:        row in a matrix providing the data that one can use to correctly preallocate the matrix.

    497:    Synopsis:
    498:    PetscErrorCode MatPreallocateSymmetricInitialize(MPI_Comm comm, PetscInt nrows, PetscInt ncols, PetscInt *dnz, PetscInt *onz)

    500:    Collective on MPI_Comm

    502:    Input Parameters:
    503: +  comm - the communicator that will share the eventually allocated matrix
    504: .  nrows - the number of rows in the matrix
    505: -  ncols - the number of columns in the matrix

    507:    Output Parameters:
    508: +  dnz - the array that will be passed to the matrix preallocation routines
    509: -  ozn - the other array passed to the matrix preallocation routines

    512:    Level: intermediate

    514:    Notes:
    515:    See the chapter in the users manual on performance for more details

    517:    Do not malloc or free dnz and onz, that is handled internally by these routines

    519:   Concepts: preallocation^Matrix

    521: .seealso: MatPreallocateFinalize(), MatPreallocateSet(), MatPreallocateSymmetricSet(), MatPreallocateSetLocal(),
    522:           MatPreallocateInitialize(), MatPreallocateSymmetricSetLocal()
    523: M*/
    524: #define MatPreallocateSymmetricInitialize(comm,nrows,ncols,dnz,onz) 0; \
    525: { \
    526:   PetscErrorCode _4_ierr; PetscInt __tmp = (nrows),__ctmp = (ncols),__rstart,__end; \
    527:   _4_PetscMalloc(2*__tmp*sizeof(PetscInt),&dnz);CHKERRQ(_4_ierr);onz = dnz + __tmp;\
    528:   _4_PetscMemzero(dnz,2*__tmp*sizeof(PetscInt));CHKERRQ(_4_ierr);\
    529:   _4_MPI_Scan(&__ctmp,&__end,1,MPIU_INT,MPI_SUM,comm);CHKERRQ(_4_ierr);\
    530:   _4_MPI_Scan(&__tmp,&__rstart,1,MPIU_INT,MPI_SUM,comm);CHKERRQ(_4_ierr); __rstart = __rstart - __tmp;

    532: /*MC
    533:    MatPreallocateSetLocal - Indicates the locations (rows and columns) in the matrix where nonzeros will be
    534:        inserted using a local number of the rows and columns

    536:    Synopsis:
    537:    PetscErrorCode MatPreallocateSetLocal(ISLocalToGlobalMappping map,PetscInt nrows, PetscInt *rows,PetscInt ncols, PetscInt *cols,PetscInt *dnz, PetscInt *onz)

    539:    Not Collective

    541:    Input Parameters:
    542: +  map - the mapping between local numbering and global numbering
    543: .  nrows - the number of rows indicated
    544: .  rows - the indices of the rows
    545: .  ncols - the number of columns in the matrix
    546: .  cols - the columns indicated
    547: .  dnz - the array that will be passed to the matrix preallocation routines
    548: -  ozn - the other array passed to the matrix preallocation routines

    551:    Level: intermediate

    553:    Notes:
    554:    See the chapter in the users manual on performance for more details

    556:    Do not malloc or free dnz and onz, that is handled internally by these routines

    558:   Concepts: preallocation^Matrix

    560: .seealso: MatPreallocateFinalize(), MatPreallocateSet(), MatPreallocateSymmetricSet(), MatPreallocateInitialize(),
    561:           MatPreallocateInitialize(), MatPreallocateSymmetricSetLocal()
    562: M*/
    563: #define MatPreallocateSetLocal(map,nrows,rows,ncols,cols,dnz,onz) 0;\
    564: {\
    565:   PetscInt __l;\
    566:   _4_ISLocalToGlobalMappingApply(map,nrows,rows,rows);CHKERRQ(_4_ierr);\
    567:   _4_ISLocalToGlobalMappingApply(map,ncols,cols,cols);CHKERRQ(_4_ierr);\
    568:   for (__l=0;__l<nrows;__l++) {\
    569:     _4_MatPreallocateSet((rows)[__l],ncols,cols,dnz,onz);CHKERRQ(_4_ierr);\
    570:   }\
    571: }
    572:
    573: /*MC
    574:    MatPreallocateSymmetricSetLocal - Indicates the locations (rows and columns) in the matrix where nonzeros will be
    575:        inserted using a local number of the rows and columns

    577:    Synopsis:
    578:    PetscErrorCode MatPreallocateSymmetricSetLocal(ISLocalToGlobalMappping map,PetscInt nrows, PetscInt *rows,PetscInt ncols, PetscInt *cols,PetscInt *dnz, PetscInt *onz)

    580:    Not Collective

    582:    Input Parameters:
    583: +  map - the mapping between local numbering and global numbering
    584: .  nrows - the number of rows indicated
    585: .  rows - the indices of the rows
    586: .  ncols - the number of columns in the matrix
    587: .  cols - the columns indicated
    588: .  dnz - the array that will be passed to the matrix preallocation routines
    589: -  ozn - the other array passed to the matrix preallocation routines

    592:    Level: intermediate

    594:    Notes:
    595:    See the chapter in the users manual on performance for more details

    597:    Do not malloc or free dnz and onz that is handled internally by these routines

    599:   Concepts: preallocation^Matrix

    601: .seealso: MatPreallocateFinalize(), MatPreallocateSet(), MatPreallocateSymmetricSet(), MatPreallocateInitialize(),
    602:           MatPreallocateInitialize(), MatPreallocateSymmetricSetLocal(), MatPreallocateSetLocal()
    603: M*/
    604: #define MatPreallocateSymmetricSetLocal(map,nrows,rows,ncols,cols,dnz,onz) 0;\
    605: {\
    606:   PetscInt __l;\
    607:   _4_ISLocalToGlobalMappingApply(map,nrows,rows,rows);CHKERRQ(_4_ierr);\
    608:   _4_ISLocalToGlobalMappingApply(map,ncols,cols,cols);CHKERRQ(_4_ierr);\
    609:   for (__l=0;__l<nrows;__l++) {\
    610:     _4_MatPreallocateSymmetricSet((rows)[__l],ncols,cols,dnz,onz);CHKERRQ(_4_ierr);\
    611:   }\
    612: }

    614: /*MC
    615:    MatPreallocateSet - Indicates the locations (rows and columns) in the matrix where nonzeros will be
    616:        inserted using a local number of the rows and columns

    618:    Synopsis:
    619:    PetscErrorCode MatPreallocateSet(PetscInt nrows, PetscInt *rows,PetscInt ncols, PetscInt *cols,PetscInt *dnz, PetscInt *onz)

    621:    Not Collective

    623:    Input Parameters:
    624: +  nrows - the number of rows indicated
    625: .  rows - the indices of the rows
    626: .  ncols - the number of columns in the matrix
    627: -  cols - the columns indicated

    629:    Output Parameters:
    630: +  dnz - the array that will be passed to the matrix preallocation routines
    631: -  ozn - the other array passed to the matrix preallocation routines

    634:    Level: intermediate

    636:    Notes:
    637:    See the chapter in the users manual on performance for more details

    639:    Do not malloc or free dnz and onz that is handled internally by these routines

    641:   Concepts: preallocation^Matrix

    643: .seealso: MatPreallocateFinalize(), MatPreallocateSet(), MatPreallocateSymmetricSet(), MatPreallocateInitialize(),
    644:           MatPreallocateInitialize(), MatPreallocateSymmetricSetLocal(), MatPreallocateSetLocal()
    645: M*/
    646: #define MatPreallocateSet(row,nc,cols,dnz,onz) 0;\
    647: { PetscInt __i; \
    648:   for (__i=0; __i<nc; __i++) {\
    649:     if (cols[__i] < __start || cols[__i] >= __end) onz[row - __rstart]++; \
    650:   }\
    651:   dnz[row - __rstart] = nc - onz[row - __rstart];\
    652: }

    654: /*MC
    655:    MatPreallocateSymmetricSet - Indicates the locations (rows and columns) in the matrix where nonzeros will be
    656:        inserted using a local number of the rows and columns

    658:    Synopsis:
    659:    PetscErrorCode MatPreallocateSymmetricSet(PetscInt nrows, PetscInt *rows,PetscInt ncols, PetscInt *cols,PetscInt *dnz, PetscInt *onz)

    661:    Not Collective

    663:    Input Parameters:
    664: +  nrows - the number of rows indicated
    665: .  rows - the indices of the rows
    666: .  ncols - the number of columns in the matrix
    667: .  cols - the columns indicated
    668: .  dnz - the array that will be passed to the matrix preallocation routines
    669: -  ozn - the other array passed to the matrix preallocation routines

    672:    Level: intermediate

    674:    Notes:
    675:    See the chapter in the users manual on performance for more details

    677:    Do not malloc or free dnz and onz that is handled internally by these routines

    679:   Concepts: preallocation^Matrix

    681: .seealso: MatPreallocateFinalize(), MatPreallocateSet(), MatPreallocateSymmetricSet(), MatPreallocateInitialize(),
    682:           MatPreallocateInitialize(), MatPreallocateSymmetricSetLocal(), MatPreallocateSetLocal()
    683: M*/
    684: #define MatPreallocateSymmetricSet(row,nc,cols,dnz,onz) 0;\
    685: { PetscInt __i; \
    686:   for (__i=0; __i<nc; __i++) {\
    687:     if (cols[__i] >= __end) onz[row - __rstart]++; \
    688:     else if (cols[__i] >= row) dnz[row - __rstart]++;\
    689:   }\
    690: }

    692: /*MC
    693:    MatPreallocFinalize - Ends the block of code that will count the number of nonzeros per
    694:        row in a matrix providing the data that one can use to correctly preallocate the matrix.

    696:    Synopsis:
    697:    PetscErrorCode MatPreallocateFinalize(PetscInt *dnz, PetscInt *onz)

    699:    Collective on MPI_Comm

    701:    Input Parameters:
    702: +  dnz - the array that will be passed to the matrix preallocation routines
    703: -  ozn - the other array passed to the matrix preallocation routines

    706:    Level: intermediate

    708:    Notes:
    709:    See the chapter in the users manual on performance for more details

    711:    Do not malloc or free dnz and onz that is handled internally by these routines

    713:   Concepts: preallocation^Matrix

    715: .seealso: MatPreallocateInitialize(), MatPreallocateSet(), MatPreallocateSymmetricSet(), MatPreallocateSetLocal(),
    716:           MatPreallocateSymmetricInitialize(), MatPreallocateSymmetricSetLocal()
    717: M*/
    718: #define MatPreallocateFinalize(dnz,onz) 0;_4_PetscFree(dnz);CHKERRQ(_4_ierr);}

    722: /* Routines unique to particular data structures */
    723: EXTERN PetscErrorCode MatShellGetContext(Mat,void **);

    725: EXTERN PetscErrorCode MatBDiagGetData(Mat,PetscInt*,PetscInt*,PetscInt*[],PetscInt*[],PetscScalar***);
    726: EXTERN PetscErrorCode MatSeqAIJSetColumnIndices(Mat,PetscInt[]);
    727: EXTERN PetscErrorCode MatSeqBAIJSetColumnIndices(Mat,PetscInt[]);
    728: EXTERN PetscErrorCode MatCreateSeqAIJWithArrays(MPI_Comm,PetscInt,PetscInt,PetscInt[],PetscInt[],PetscScalar[],Mat*);

    730: EXTERN PetscErrorCode MatSeqBAIJSetPreallocation(Mat,PetscInt,PetscInt,const PetscInt[]);
    731: EXTERN PetscErrorCode MatSeqSBAIJSetPreallocation(Mat,PetscInt,PetscInt,const PetscInt[]);
    732: EXTERN PetscErrorCode MatSeqAIJSetPreallocation(Mat,PetscInt,const PetscInt[]);
    733: EXTERN PetscErrorCode MatSeqDensePreallocation(Mat,PetscScalar[]);
    734: EXTERN PetscErrorCode MatSeqBDiagSetPreallocation(Mat,PetscInt,PetscInt,const PetscInt[],PetscScalar*[]);
    735: EXTERN PetscErrorCode MatSeqDenseSetPreallocation(Mat,PetscScalar[]);

    737: EXTERN PetscErrorCode MatMPIBAIJSetPreallocation(Mat,PetscInt,PetscInt,const PetscInt[],PetscInt,const PetscInt[]);
    738: EXTERN PetscErrorCode MatMPISBAIJSetPreallocation(Mat,PetscInt,PetscInt,const PetscInt[],PetscInt,const PetscInt[]);
    739: EXTERN PetscErrorCode MatMPIAIJSetPreallocation(Mat,PetscInt,const PetscInt[],PetscInt,const PetscInt[]);
    740: EXTERN PetscErrorCode MatMPIAIJSetPreallocationCSR(Mat,const PetscInt[],const PetscInt[],const PetscScalar[]);
    741: EXTERN PetscErrorCode MatMPIBAIJSetPreallocationCSR(Mat,PetscInt,const PetscInt[],const PetscInt[],const PetscScalar[]);
    742: EXTERN PetscErrorCode MatMPIDensePreallocation(Mat,PetscScalar[]);
    743: EXTERN PetscErrorCode MatMPIBDiagSetPreallocation(Mat,PetscInt,PetscInt,const PetscInt[],PetscScalar*[]);
    744: EXTERN PetscErrorCode MatMPIAdjSetPreallocation(Mat,PetscInt[],PetscInt[],PetscInt[]);
    745: EXTERN PetscErrorCode MatMPIDenseSetPreallocation(Mat,PetscScalar[]);
    746: EXTERN PetscErrorCode MatMPIRowbsSetPreallocation(Mat,PetscInt,const PetscInt[]);
    747: EXTERN PetscErrorCode MatMPIAIJGetSeqAIJ(Mat,Mat*,Mat*,PetscInt*[]);
    748: EXTERN PetscErrorCode MatMPIBAIJGetSeqBAIJ(Mat,Mat*,Mat*,PetscInt*[]);
    749: EXTERN PetscErrorCode MatAdicSetLocalFunction(Mat,void (*)(void));

    751: EXTERN PetscErrorCode MatSeqDenseSetLDA(Mat,PetscInt);

    753: EXTERN PetscErrorCode MatStoreValues(Mat);
    754: EXTERN PetscErrorCode MatRetrieveValues(Mat);

    756: EXTERN PetscErrorCode MatDAADSetCtx(Mat,void*);

    758: /*
    759:   These routines are not usually accessed directly, rather solving is
    760:   done through the KSP and PC interfaces.
    761: */

    763: /*E
    764:     MatOrderingType - String with the name of a PETSc matrix ordering or the creation function
    765:        with an optional dynamic library name, for example
    766:        http://www.mcs.anl.gov/petsc/lib.a:orderingcreate()

    768:    Level: beginner

    770: .seealso: MatGetOrdering()
    771: E*/
    772: #define MatOrderingType char*
    773: #define MATORDERING_NATURAL   "natural"
    774: #define MATORDERING_ND        "nd"
    775: #define MATORDERING_1WD       "1wd"
    776: #define MATORDERING_RCM       "rcm"
    777: #define MATORDERING_QMD       "qmd"
    778: #define MATORDERING_ROWLENGTH "rowlength"
    779: #define MATORDERING_DSC_ND    "dsc_nd"
    780: #define MATORDERING_DSC_MMD   "dsc_mmd"
    781: #define MATORDERING_DSC_MDF   "dsc_mdf"
    782: #define MATORDERING_CONSTRAINED "constrained"
    783: #define MATORDERING_IDENTITY  "identity"
    784: #define MATORDERING_REVERSE   "reverse"

    786: EXTERN PetscErrorCode MatGetOrdering(Mat,const MatOrderingType,IS*,IS*);
    787: EXTERN PetscErrorCode MatOrderingRegister(const char[],const char[],const char[],PetscErrorCode(*)(Mat,const MatOrderingType,IS*,IS*));

    789: /*MC
    790:    MatOrderingRegisterDynamic - Adds a new sparse matrix ordering to the
    791:                                matrix package.

    793:    Synopsis:
    794:    PetscErrorCode MatOrderingRegisterDynamic(char *name_ordering,char *path,char *name_create,PetscErrorCode (*routine_create)(MatOrdering))

    796:    Not Collective

    798:    Input Parameters:
    799: +  sname - name of ordering (for example MATORDERING_ND)
    800: .  path - location of library where creation routine is
    801: .  name - name of function that creates the ordering type,a string
    802: -  function - function pointer that creates the ordering

    804:    Level: developer

    806:    If dynamic libraries are used, then the fourth input argument (function)
    807:    is ignored.

    809:    Sample usage:
    810: .vb
    811:    MatOrderingRegisterDynamic("my_order",/home/username/my_lib/lib/libO/solaris/mylib.a,
    812:                "MyOrder",MyOrder);
    813: .ve

    815:    Then, your partitioner can be chosen with the procedural interface via
    816: $     MatOrderingSetType(part,"my_order)
    817:    or at runtime via the option
    818: $     -pc_ilu_mat_ordering_type my_order
    819: $     -pc_lu_mat_ordering_type my_order

    821:    ${PETSC_ARCH} and ${BOPT} occuring in pathname will be replaced with appropriate values.

    823: .keywords: matrix, ordering, register

    825: .seealso: MatOrderingRegisterDestroy(), MatOrderingRegisterAll()
    826: M*/
    827: #if defined(PETSC_USE_DYNAMIC_LIBRARIES)
    828: #define MatOrderingRegisterDynamic(a,b,c,d) MatOrderingRegister(a,b,c,0)
    829: #else
    830: #define MatOrderingRegisterDynamic(a,b,c,d) MatOrderingRegister(a,b,c,d)
    831: #endif

    833: EXTERN PetscErrorCode        MatOrderingRegisterDestroy(void);
    834: EXTERN PetscErrorCode        MatOrderingRegisterAll(const char[]);

    838: EXTERN PetscErrorCode MatReorderForNonzeroDiagonal(Mat,PetscReal,IS,IS);

    840: /*S
    841:    MatFactorInfo - Data based into the matrix factorization routines

    843:    In Fortran these are simply double precision arrays of size MAT_FACTORINFO_SIZE

    845:    Notes: These are not usually directly used by users, instead use PC type of LU, ILU, CHOLESKY or ICC.

    847:    Level: developer

    849: .seealso: MatLUFactorSymbolic(), MatILUFactorSymbolic(), MatCholeskyFactorSymbolic(), MatICCFactorSymbolic(), MatICCFactor(),
    850:           MatFactorInfoInitialize()

    852: S*/
    853: typedef struct {
    854:   PetscReal     damping;        /* scaling of identity added to matrix to prevent zero pivots */
    855:   PetscReal     shift;          /* if true, shift until positive pivots */
    856:   PetscReal     shift_fraction; /* record shift fraction taken */
    857:   PetscReal     diagonal_fill;  /* force diagonal to fill in if initially not filled */
    858:   PetscReal     dt;             /* drop tolerance */
    859:   PetscReal     dtcol;          /* tolerance for pivoting */
    860:   PetscReal     dtcount;        /* maximum nonzeros to be allowed per row */
    861:   PetscReal     fill;           /* expected fill; nonzeros in factored matrix/nonzeros in original matrix*/
    862:   PetscReal     levels;         /* ICC/ILU(levels) */
    863:   PetscReal     pivotinblocks;  /* for BAIJ and SBAIJ matrices pivot in factorization on blocks, default 1.0
    864:                                    factorization may be faster if do not pivot */
    865:   PetscReal     zeropivot;      /* pivot is called zero if less than this */
    866: } MatFactorInfo;

    868: EXTERN PetscErrorCode MatFactorInfoInitialize(MatFactorInfo*);
    869: EXTERN PetscErrorCode MatCholeskyFactor(Mat,IS,MatFactorInfo*);
    870: EXTERN PetscErrorCode MatCholeskyFactorSymbolic(Mat,IS,MatFactorInfo*,Mat*);
    871: EXTERN PetscErrorCode MatCholeskyFactorNumeric(Mat,Mat*);
    872: EXTERN PetscErrorCode MatLUFactor(Mat,IS,IS,MatFactorInfo*);
    873: EXTERN PetscErrorCode MatILUFactor(Mat,IS,IS,MatFactorInfo*);
    874: EXTERN PetscErrorCode MatLUFactorSymbolic(Mat,IS,IS,MatFactorInfo*,Mat*);
    875: EXTERN PetscErrorCode MatILUFactorSymbolic(Mat,IS,IS,MatFactorInfo*,Mat*);
    876: EXTERN PetscErrorCode MatICCFactorSymbolic(Mat,IS,MatFactorInfo*,Mat*);
    877: EXTERN PetscErrorCode MatICCFactor(Mat,IS,MatFactorInfo*);
    878: EXTERN PetscErrorCode MatLUFactorNumeric(Mat,Mat*);
    879: EXTERN PetscErrorCode MatILUDTFactor(Mat,MatFactorInfo*,IS,IS,Mat *);
    880: EXTERN PetscErrorCode MatGetInertia(Mat,PetscInt*,PetscInt*,PetscInt*);
    881: EXTERN PetscErrorCode MatSolve(Mat,Vec,Vec);
    882: EXTERN PetscErrorCode MatForwardSolve(Mat,Vec,Vec);
    883: EXTERN PetscErrorCode MatBackwardSolve(Mat,Vec,Vec);
    884: EXTERN PetscErrorCode MatSolveAdd(Mat,Vec,Vec,Vec);
    885: EXTERN PetscErrorCode MatSolveTranspose(Mat,Vec,Vec);
    886: EXTERN PetscErrorCode MatSolveTransposeAdd(Mat,Vec,Vec,Vec);
    887: EXTERN PetscErrorCode MatSolves(Mat,Vecs,Vecs);

    889: EXTERN PetscErrorCode MatSetUnfactored(Mat);

    891: /*E
    892:     MatSORType - What type of (S)SOR to perform

    894:     Level: beginner

    896:    May be bitwise ORd together

    898:    Any additions/changes here MUST also be made in include/finclude/petscmat.h

    900:    MatSORType may be bitwise ORd together, so do not change the numbers

    902: .seealso: MatRelax(), MatPBRelax()
    903: E*/
    904: typedef enum {SOR_FORWARD_SWEEP=1,SOR_BACKWARD_SWEEP=2,SOR_SYMMETRIC_SWEEP=3,
    905:               SOR_LOCAL_FORWARD_SWEEP=4,SOR_LOCAL_BACKWARD_SWEEP=8,
    906:               SOR_LOCAL_SYMMETRIC_SWEEP=12,SOR_ZERO_INITIAL_GUESS=16,
    907:               SOR_EISENSTAT=32,SOR_APPLY_UPPER=64,SOR_APPLY_LOWER=128} MatSORType;
    908: EXTERN PetscErrorCode MatRelax(Mat,Vec,PetscReal,MatSORType,PetscReal,PetscInt,PetscInt,Vec);
    909: EXTERN PetscErrorCode MatPBRelax(Mat,Vec,PetscReal,MatSORType,PetscReal,PetscInt,PetscInt,Vec);

    911: /*
    912:     These routines are for efficiently computing Jacobians via finite differences.
    913: */

    915: /*E
    916:     MatColoringType - String with the name of a PETSc matrix coloring or the creation function
    917:        with an optional dynamic library name, for example
    918:        http://www.mcs.anl.gov/petsc/lib.a:coloringcreate()

    920:    Level: beginner

    922: .seealso: MatGetColoring()
    923: E*/
    924: #define MatColoringType char*
    925: #define MATCOLORING_NATURAL "natural"
    926: #define MATCOLORING_SL      "sl"
    927: #define MATCOLORING_LF      "lf"
    928: #define MATCOLORING_ID      "id"

    930: EXTERN PetscErrorCode MatGetColoring(Mat,const MatColoringType,ISColoring*);
    931: EXTERN PetscErrorCode MatColoringRegister(const char[],const char[],const char[],PetscErrorCode(*)(Mat,const MatColoringType,ISColoring *));

    933: /*MC
    934:    MatColoringRegisterDynamic - Adds a new sparse matrix coloring to the
    935:                                matrix package.

    937:    Synopsis:
    938:    PetscErrorCode MatColoringRegisterDynamic(char *name_coloring,char *path,char *name_create,PetscErrorCode (*routine_create)(MatColoring))

    940:    Not Collective

    942:    Input Parameters:
    943: +  sname - name of Coloring (for example MATCOLORING_SL)
    944: .  path - location of library where creation routine is
    945: .  name - name of function that creates the Coloring type, a string
    946: -  function - function pointer that creates the coloring

    948:    Level: developer

    950:    If dynamic libraries are used, then the fourth input argument (function)
    951:    is ignored.

    953:    Sample usage:
    954: .vb
    955:    MatColoringRegisterDynamic("my_color",/home/username/my_lib/lib/libO/solaris/mylib.a,
    956:                "MyColor",MyColor);
    957: .ve

    959:    Then, your partitioner can be chosen with the procedural interface via
    960: $     MatColoringSetType(part,"my_color")
    961:    or at runtime via the option
    962: $     -mat_coloring_type my_color

    964:    $PETSC_ARCH and $BOPT occuring in pathname will be replaced with appropriate values.

    966: .keywords: matrix, Coloring, register

    968: .seealso: MatColoringRegisterDestroy(), MatColoringRegisterAll()
    969: M*/
    970: #if defined(PETSC_USE_DYNAMIC_LIBRARIES)
    971: #define MatColoringRegisterDynamic(a,b,c,d) MatColoringRegister(a,b,c,0)
    972: #else
    973: #define MatColoringRegisterDynamic(a,b,c,d) MatColoringRegister(a,b,c,d)
    974: #endif

    976: EXTERN PetscErrorCode        MatColoringRegisterAll(const char[]);
    978: EXTERN PetscErrorCode        MatColoringRegisterDestroy(void);
    979: EXTERN PetscErrorCode        MatColoringPatch(Mat,PetscInt,PetscInt,ISColoringValue[],ISColoring*);

    981: /*S
    982:      MatFDColoring - Object for computing a sparse Jacobian via finite differences
    983:         and coloring

    985:    Level: beginner

    987:   Concepts: coloring, sparse Jacobian, finite differences

    989: .seealso:  MatFDColoringCreate()
    990: S*/
    991: typedef struct _p_MatFDColoring *MatFDColoring;

    993: EXTERN PetscErrorCode MatFDColoringCreate(Mat,ISColoring,MatFDColoring *);
    994: EXTERN PetscErrorCode MatFDColoringDestroy(MatFDColoring);
    995: EXTERN PetscErrorCode MatFDColoringView(MatFDColoring,PetscViewer);
    996: EXTERN PetscErrorCode MatFDColoringSetFunction(MatFDColoring,PetscErrorCode (*)(void),void*);
    997: EXTERN PetscErrorCode MatFDColoringSetParameters(MatFDColoring,PetscReal,PetscReal);
    998: EXTERN PetscErrorCode MatFDColoringSetFrequency(MatFDColoring,PetscInt);
    999: EXTERN PetscErrorCode MatFDColoringGetFrequency(MatFDColoring,PetscInt*);
    1000: EXTERN PetscErrorCode MatFDColoringSetFromOptions(MatFDColoring);
    1001: EXTERN PetscErrorCode MatFDColoringApply(Mat,MatFDColoring,Vec,MatStructure*,void *);
    1002: EXTERN PetscErrorCode MatFDColoringApplyTS(Mat,MatFDColoring,PetscReal,Vec,MatStructure*,void *);
    1003: EXTERN PetscErrorCode MatFDColoringSetRecompute(MatFDColoring);
    1004: EXTERN PetscErrorCode MatFDColoringSetF(MatFDColoring,Vec);
    1005: EXTERN PetscErrorCode MatFDColoringGetPerturbedColumns(MatFDColoring,PetscInt*,PetscInt*[]);
    1006: /*
    1007:     These routines are for partitioning matrices: currently used only
    1008:   for adjacency matrix, MatCreateMPIAdj().
    1009: */

    1011: /*S
    1012:      MatPartitioning - Object for managing the partitioning of a matrix or graph

    1014:    Level: beginner

    1016:   Concepts: partitioning

    1018: .seealso:  MatPartitioningCreate(), MatPartitioningType
    1019: S*/
    1020: typedef struct _p_MatPartitioning *MatPartitioning;

    1022: /*E
    1023:     MatPartitioningType - String with the name of a PETSc matrix partitioning or the creation function
    1024:        with an optional dynamic library name, for example
    1025:        http://www.mcs.anl.gov/petsc/lib.a:partitioningcreate()

    1027:    Level: beginner

    1029: .seealso: MatPartitioningCreate(), MatPartitioning
    1030: E*/
    1031: #define MatPartitioningType char*
    1032: #define MAT_PARTITIONING_CURRENT  "current"
    1033: #define MAT_PARTITIONING_PARMETIS "parmetis"
    1034: #define MAT_PARTITIONING_CHACO    "chaco"
    1035: #define MAT_PARTITIONING_JOSTLE   "jostle"
    1036: #define MAT_PARTITIONING_PARTY    "party"
    1037: #define MAT_PARTITIONING_SCOTCH   "scotch"

    1040: EXTERN PetscErrorCode MatPartitioningCreate(MPI_Comm,MatPartitioning*);
    1041: EXTERN PetscErrorCode MatPartitioningSetType(MatPartitioning,const MatPartitioningType);
    1042: EXTERN PetscErrorCode MatPartitioningSetNParts(MatPartitioning,PetscInt);
    1043: EXTERN PetscErrorCode MatPartitioningSetAdjacency(MatPartitioning,Mat);
    1044: EXTERN PetscErrorCode MatPartitioningSetVertexWeights(MatPartitioning,const PetscInt[]);
    1045: EXTERN PetscErrorCode MatPartitioningSetPartitionWeights(MatPartitioning,const PetscReal []);
    1046: EXTERN PetscErrorCode MatPartitioningApply(MatPartitioning,IS*);
    1047: EXTERN PetscErrorCode MatPartitioningDestroy(MatPartitioning);

    1049: EXTERN PetscErrorCode MatPartitioningRegister(const char[],const char[],const char[],PetscErrorCode (*)(MatPartitioning));

    1051: /*MC
    1052:    MatPartitioningRegisterDynamic - Adds a new sparse matrix partitioning to the
    1053:    matrix package.

    1055:    Synopsis:
    1056:    PetscErrorCode MatPartitioningRegisterDynamic(char *name_partitioning,char *path,char *name_create,PetscErrorCode (*routine_create)(MatPartitioning))

    1058:    Not Collective

    1060:    Input Parameters:
    1061: +  sname - name of partitioning (for example MAT_PARTITIONING_CURRENT) or parmetis
    1062: .  path - location of library where creation routine is
    1063: .  name - name of function that creates the partitioning type, a string
    1064: -  function - function pointer that creates the partitioning type

    1066:    Level: developer

    1068:    If dynamic libraries are used, then the fourth input argument (function)
    1069:    is ignored.

    1071:    Sample usage:
    1072: .vb
    1073:    MatPartitioningRegisterDynamic("my_part",/home/username/my_lib/lib/libO/solaris/mylib.a,
    1074:                "MyPartCreate",MyPartCreate);
    1075: .ve

    1077:    Then, your partitioner can be chosen with the procedural interface via
    1078: $     MatPartitioningSetType(part,"my_part")
    1079:    or at runtime via the option
    1080: $     -mat_partitioning_type my_part

    1082:    $PETSC_ARCH and $BOPT occuring in pathname will be replaced with appropriate values.

    1084: .keywords: matrix, partitioning, register

    1086: .seealso: MatPartitioningRegisterDestroy(), MatPartitioningRegisterAll()
    1087: M*/
    1088: #if defined(PETSC_USE_DYNAMIC_LIBRARIES)
    1089: #define MatPartitioningRegisterDynamic(a,b,c,d) MatPartitioningRegister(a,b,c,0)
    1090: #else
    1091: #define MatPartitioningRegisterDynamic(a,b,c,d) MatPartitioningRegister(a,b,c,d)
    1092: #endif

    1094: EXTERN PetscErrorCode        MatPartitioningRegisterAll(const char[]);
    1096: EXTERN PetscErrorCode        MatPartitioningRegisterDestroy(void);

    1098: EXTERN PetscErrorCode MatPartitioningView(MatPartitioning,PetscViewer);
    1099: EXTERN PetscErrorCode MatPartitioningSetFromOptions(MatPartitioning);
    1100: EXTERN PetscErrorCode MatPartitioningGetType(MatPartitioning,MatPartitioningType*);

    1102: EXTERN PetscErrorCode MatPartitioningParmetisSetCoarseSequential(MatPartitioning);

    1104: EXTERN PetscErrorCode MatPartitioningJostleSetCoarseLevel(MatPartitioning,PetscReal);
    1105: EXTERN PetscErrorCode MatPartitioningJostleSetCoarseSequential(MatPartitioning);

    1107: typedef enum { MP_CHACO_MULTILEVEL_KL, MP_CHACO_SPECTRAL, MP_CHACO_LINEAR,
    1108:     MP_CHACO_RANDOM, MP_CHACO_SCATTERED } MPChacoGlobalType;
    1109: EXTERN PetscErrorCode MatPartitioningChacoSetGlobal(MatPartitioning, MPChacoGlobalType);
    1110: typedef enum { MP_CHACO_KERNIGHAN_LIN, MP_CHACO_NONE } MPChacoLocalType;
    1111: EXTERN PetscErrorCode MatPartitioningChacoSetLocal(MatPartitioning, MPChacoLocalType);
    1112: EXTERN PetscErrorCode MatPartitioningChacoSetCoarseLevel(MatPartitioning,PetscReal);
    1113: typedef enum { MP_CHACO_LANCZOS, MP_CHACO_RQI_SYMMLQ } MPChacoEigenType;
    1114: EXTERN PetscErrorCode MatPartitioningChacoSetEigenSolver(MatPartitioning,MPChacoEigenType);
    1115: EXTERN PetscErrorCode MatPartitioningChacoSetEigenTol(MatPartitioning, PetscReal);
    1116: EXTERN PetscErrorCode MatPartitioningChacoSetEigenNumber(MatPartitioning, PetscInt);

    1118: #define MP_PARTY_OPT "opt"
    1119: #define MP_PARTY_LIN "lin"
    1120: #define MP_PARTY_SCA "sca"
    1121: #define MP_PARTY_RAN "ran"
    1122: #define MP_PARTY_GBF "gbf"
    1123: #define MP_PARTY_GCF "gcf"
    1124: #define MP_PARTY_BUB "bub"
    1125: #define MP_PARTY_DEF "def"
    1126: EXTERN PetscErrorCode MatPartitioningPartySetGlobal(MatPartitioning, const char*);
    1127: #define MP_PARTY_HELPFUL_SETS "hs"
    1128: #define MP_PARTY_KERNIGHAN_LIN "kl"
    1129: #define MP_PARTY_NONE "no"
    1130: EXTERN PetscErrorCode MatPartitioningPartySetLocal(MatPartitioning, const char*);
    1131: EXTERN PetscErrorCode MatPartitioningPartySetCoarseLevel(MatPartitioning,PetscReal);
    1132: EXTERN PetscErrorCode MatPartitioningPartySetBipart(MatPartitioning,PetscTruth);
    1133: EXTERN PetscErrorCode MatPartitioningPartySetMatchOptimization(MatPartitioning,PetscTruth);

    1135: typedef enum { MP_SCOTCH_GREEDY, MP_SCOTCH_GPS, MP_SCOTCH_GR_GPS } MPScotchGlobalType;
    1136: EXTERN PetscErrorCode MatPartitioningScotchSetArch(MatPartitioning,const char*);
    1137: EXTERN PetscErrorCode MatPartitioningScotchSetMultilevel(MatPartitioning);
    1138: EXTERN PetscErrorCode MatPartitioningScotchSetGlobal(MatPartitioning,MPScotchGlobalType);
    1139: EXTERN PetscErrorCode MatPartitioningScotchSetCoarseLevel(MatPartitioning,PetscReal);
    1140: EXTERN PetscErrorCode MatPartitioningScotchSetHostList(MatPartitioning,const char*);
    1141: typedef enum { MP_SCOTCH_KERNIGHAN_LIN, MP_SCOTCH_NONE } MPScotchLocalType;
    1142: EXTERN PetscErrorCode MatPartitioningScotchSetLocal(MatPartitioning,MPScotchLocalType);
    1143: EXTERN PetscErrorCode MatPartitioningScotchSetMapping(MatPartitioning);
    1144: EXTERN PetscErrorCode MatPartitioningScotchSetStrategy(MatPartitioning,char*);

    1146: /*
    1147:     If you add entries here you must also add them to finclude/petscmat.h
    1148: */
    1149: typedef enum { MATOP_SET_VALUES=0,
    1150:                MATOP_GET_ROW=1,
    1151:                MATOP_RESTORE_ROW=2,
    1152:                MATOP_MULT=3,
    1153:                MATOP_MULT_ADD=4,
    1154:                MATOP_MULT_TRANSPOSE=5,
    1155:                MATOP_MULT_TRANSPOSE_ADD=6,
    1156:                MATOP_SOLVE=7,
    1157:                MATOP_SOLVE_ADD=8,
    1158:                MATOP_SOLVE_TRANSPOSE=9,
    1159:                MATOP_SOLVE_TRANSPOSE_ADD=10,
    1160:                MATOP_LUFACTOR=11,
    1161:                MATOP_CHOLESKYFACTOR=12,
    1162:                MATOP_RELAX=13,
    1163:                MATOP_TRANSPOSE=14,
    1164:                MATOP_GETINFO=15,
    1165:                MATOP_EQUAL=16,
    1166:                MATOP_GET_DIAGONAL=17,
    1167:                MATOP_DIAGONAL_SCALE=18,
    1168:                MATOP_NORM=19,
    1169:                MATOP_ASSEMBLY_BEGIN=20,
    1170:                MATOP_ASSEMBLY_END=21,
    1171:                MATOP_COMPRESS=22,
    1172:                MATOP_SET_OPTION=23,
    1173:                MATOP_ZERO_ENTRIES=24,
    1174:                MATOP_ZERO_ROWS=25,
    1175:                MATOP_LUFACTOR_SYMBOLIC=26,
    1176:                MATOP_LUFACTOR_NUMERIC=27,
    1177:                MATOP_CHOLESKY_FACTOR_SYMBOLIC=28,
    1178:                MATOP_CHOLESKY_FACTOR_NUMERIC=29,
    1179:                MATOP_SETUP_PREALLOCATION=30,
    1180:                MATOP_ILUFACTOR_SYMBOLIC=31,
    1181:                MATOP_ICCFACTOR_SYMBOLIC=32,
    1182:                MATOP_GET_ARRAY=33,
    1183:                MATOP_RESTORE_ARRAY=34,
    1184:                MATOP_DUPLCIATE=35,
    1185:                MATOP_FORWARD_SOLVE=36,
    1186:                MATOP_BACKWARD_SOLVE=37,
    1187:                MATOP_ILUFACTOR=38,
    1188:                MATOP_ICCFACTOR=39,
    1189:                MATOP_AXPY=40,
    1190:                MATOP_GET_SUBMATRICES=41,
    1191:                MATOP_INCREASE_OVERLAP=42,
    1192:                MATOP_GET_VALUES=43,
    1193:                MATOP_COPY=44,
    1194:                MATOP_PRINT_HELP=45,
    1195:                MATOP_SCALE=46,
    1196:                MATOP_SHIFT=47,
    1197:                MATOP_DIAGONAL_SHIFT=48,
    1198:                MATOP_ILUDT_FACTOR=49,
    1199:                MATOP_GET_BLOCK_SIZE=50,
    1200:                MATOP_GET_ROW_IJ=51,
    1201:                MATOP_RESTORE_ROW_IJ=52,
    1202:                MATOP_GET_COLUMN_IJ=53,
    1203:                MATOP_RESTORE_COLUMN_IJ=54,
    1204:                MATOP_FDCOLORING_CREATE=55,
    1205:                MATOP_COLORING_PATCH=56,
    1206:                MATOP_SET_UNFACTORED=57,
    1207:                MATOP_PERMUTE=58,
    1208:                MATOP_SET_VALUES_BLOCKED=59,
    1209:                MATOP_GET_SUBMATRIX=60,
    1210:                MATOP_DESTROY=61,
    1211:                MATOP_VIEW=62,
    1212:                MATOP_GET_MAPS=63,
    1213:                MATOP_USE_SCALED_FORM=64,
    1214:                MATOP_SCALE_SYSTEM=65,
    1215:                MATOP_UNSCALE_SYSTEM=66,
    1216:                MATOP_SET_LOCAL_TO_GLOBAL_MAP=67,
    1217:                MATOP_SET_VALUES_LOCAL=68,
    1218:                MATOP_ZERO_ROWS_LOCAL=69,
    1219:                MATOP_GET_ROW_MAX=70,
    1220:                MATOP_CONVERT=71,
    1221:                MATOP_SET_COLORING=72,
    1222:                MATOP_SET_VALUES_ADIC=73,
    1223:                MATOP_SET_VALUES_ADIFOR=74,
    1224:                MATOP_FD_COLORING_APPLY=75,
    1225:                MATOP_SET_FROM_OPTIONS=76,
    1226:                MATOP_MULT_CON=77,
    1227:                MATOP_MULT_TRANSPOSE_CON=78,
    1228:                MATOP_ILU_FACTOR_SYMBOLIC_CON=79,
    1229:                MATOP_PERMUTE_SPARSIFY=80,
    1230:                MATOP_MULT_MULTIPLE=81,
    1231:                MATOP_SOLVE_MULTIPLE=82,
    1232:                MATOP_GET_INERTIA=83,
    1233:                MATOP_LOAD=84,
    1234:                MATOP_IS_SYMMETRIC=85,
    1235:                MATOP_IS_HERMITIAN=86,
    1236:                MATOP_IS_STRUCTURALLY_SYMMETRIC=87,
    1237:                MATOP_PB_RELAX=88,
    1238:                MATOP_GET_VECS=89,
    1239:                MATOP_MAT_MULT=90,
    1240:                MATOP_MAT_MULT_SYMBOLIC=91,
    1241:                MATOP_MAT_MULT_NUMERIC=92,
    1242:                MATOP_PTAP=93,
    1243:                MATOP_PTAP_SYMBOLIC=94,
    1244:                MATOP_PTAP_NUMERIC=95,
    1245:                MATOP_MAT_MULTTRANSPOSE=96,
    1246:                MATOP_MAT_MULTTRANSPOSE_SYMBOLIC=97,
    1247:                MATOP_MAT_MULTTRANSPOSE_NUMERIC=98
    1248:              } MatOperation;
    1249: EXTERN PetscErrorCode MatHasOperation(Mat,MatOperation,PetscTruth*);
    1250: EXTERN PetscErrorCode MatShellSetOperation(Mat,MatOperation,void(*)(void));
    1251: EXTERN PetscErrorCode MatShellGetOperation(Mat,MatOperation,void(**)(void));
    1252: EXTERN PetscErrorCode MatShellSetContext(Mat,void*);

    1254: /*
    1255:    Codes for matrices stored on disk. By default they are
    1256:  stored in a universal format. By changing the format with
    1257:  PetscViewerSetFormat(viewer,PETSC_VIEWER_BINARY_NATIVE); the matrices will
    1258:  be stored in a way natural for the matrix, for example dense matrices
    1259:  would be stored as dense. Matrices stored this way may only be
    1260:  read into matrices of the same time.
    1261: */
    1262: #define MATRIX_BINARY_FORMAT_DENSE -1

    1264: EXTERN PetscErrorCode MatMPIBAIJSetHashTableFactor(Mat,PetscReal);
    1265: EXTERN PetscErrorCode MatSeqAIJGetInodeSizes(Mat,PetscInt *,PetscInt *[],PetscInt *);
    1266: EXTERN PetscErrorCode MatMPIRowbsGetColor(Mat,ISColoring *);

    1268: EXTERN PetscErrorCode MatISGetLocalMat(Mat,Mat*);

    1270: /*S
    1271:      MatNullSpace - Object that removes a null space from a vector, i.e.
    1272:          orthogonalizes the vector to a subsapce

    1274:    Level: advanced

    1276:   Concepts: matrix; linear operator, null space

    1278:   Users manual sections:
    1279: .   Section 4.15 Solving Singular Systems

    1281: .seealso:  MatNullSpaceCreate()
    1282: S*/
    1283: typedef struct _p_MatNullSpace* MatNullSpace;

    1285: EXTERN PetscErrorCode MatNullSpaceCreate(MPI_Comm,PetscTruth,PetscInt,const Vec[],MatNullSpace*);
    1286: EXTERN PetscErrorCode MatNullSpaceDestroy(MatNullSpace);
    1287: EXTERN PetscErrorCode MatNullSpaceRemove(MatNullSpace,Vec,Vec*);
    1288: EXTERN PetscErrorCode MatNullSpaceAttach(Mat,MatNullSpace);
    1289: EXTERN PetscErrorCode MatNullSpaceTest(MatNullSpace,Mat);

    1291: EXTERN PetscErrorCode MatReorderingSeqSBAIJ(Mat,IS);
    1292: EXTERN PetscErrorCode MatMPISBAIJSetHashTableFactor(Mat,PetscReal);
    1293: EXTERN PetscErrorCode MatSeqSBAIJSetColumnIndices(Mat,PetscInt *);

    1296: EXTERN PetscErrorCode MatCreateMAIJ(Mat,PetscInt,Mat*);
    1297: EXTERN PetscErrorCode MatMAIJRedimension(Mat,PetscInt,Mat*);
    1298: EXTERN PetscErrorCode MatMAIJGetAIJ(Mat,Mat*);

    1300: EXTERN PetscErrorCode MatComputeExplicitOperator(Mat,Mat*);

    1302: EXTERN PetscErrorCode MatDiagonalScaleLocal(Mat,Vec);

    1304: EXTERN PetscErrorCode PetscViewerMathematicaPutMatrix(PetscViewer, PetscInt, PetscInt, PetscReal *);
    1305: EXTERN PetscErrorCode PetscViewerMathematicaPutCSRMatrix(PetscViewer, PetscInt, PetscInt, PetscInt *, PetscInt *, PetscReal *);

    1308: #endif