Actual source code: ex140.c

  1: static char help[] = "Tests MATPYTHON from C\n\n";

  3: #include <petscmat.h>
  4: /* MATPYTHON has support for wrapping these operations
  5:    MatHasOperation_Python inspects the user's Python class and checks
  6:    if the methods are provided */
  7: MatOperation optenum[] = {MATOP_MULT,
  8:                           MATOP_MULT_ADD,
  9:                           MATOP_MULT_TRANSPOSE,
 10:                           MATOP_MULT_TRANSPOSE_ADD,
 11:                           MATOP_SOLVE,
 12:                           MATOP_SOLVE_ADD,
 13:                           MATOP_SOLVE_TRANSPOSE,
 14:                           MATOP_SOLVE_TRANSPOSE_ADD,
 15:                           MATOP_SOR,
 16:                           MATOP_GET_DIAGONAL,
 17:                           MATOP_DIAGONAL_SCALE,
 18:                           MATOP_NORM,
 19:                           MATOP_ZERO_ENTRIES,
 20:                           MATOP_GET_DIAGONAL_BLOCK,
 21:                           MATOP_DUPLICATE,
 22:                           MATOP_COPY,
 23:                           MATOP_SCALE,
 24:                           MATOP_SHIFT,
 25:                           MATOP_DIAGONAL_SET,
 26:                           MATOP_ZERO_ROWS_COLUMNS,
 27:                           MATOP_CREATE_SUBMATRIX,
 28:                           MATOP_CREATE_VECS,
 29:                           MATOP_CONJUGATE,
 30:                           MATOP_REAL_PART,
 31:                           MATOP_IMAGINARY_PART,
 32:                           MATOP_MISSING_DIAGONAL,
 33:                           MATOP_MULT_DIAGONAL_BLOCK,
 34:                           MATOP_MULT_HERMITIAN_TRANSPOSE,
 35:                           MATOP_MULT_HERMITIAN_TRANS_ADD};

 37: /* Name of the methods in the user's Python class */
 38: const char* const optstr[] = {"mult",
 39:                               "multAdd",
 40:                               "multTranspose",
 41:                               "multTransposeAdd",
 42:                               "solve",
 43:                               "solveAdd",
 44:                               "solveTranspose",
 45:                               "solveTransposeAdd",
 46:                               "SOR",
 47:                               "getDiagonal",
 48:                               "diagonalScale",
 49:                               "norm",
 50:                               "zeroEntries",
 51:                               "getDiagonalBlock",
 52:                               "duplicate",
 53:                               "copy",
 54:                               "scale",
 55:                               "shift",
 56:                               "setDiagonal",
 57:                               "zeroRowsColumns",
 58:                               "createSubMatrix",
 59:                               "getVecs",
 60:                               "conjugate",
 61:                               "realPart",
 62:                               "imagPart",
 63:                               "missingDiagonal",
 64:                               "multDiagonalBlock",
 65:                               "multHermitian",
 66:                               "multHermitianAdd"};

 68: PetscErrorCode RunHasOperationTest()
 69: {
 70:   Mat A;
 71:   PetscInt matop, nop = sizeof(optenum)/sizeof(optenum[0]);

 73:   for (matop = 0; matop < nop; matop++) {
 74:     char opts[256];
 75:     PetscBool hasop;
 76:     PetscInt i;

 78:     PetscSNPrintf(opts,256,"-enable %s",optstr[matop]);
 79:     PetscPrintf(PETSC_COMM_WORLD,"Testing with %s\n",opts);
 80:     MatCreate(PETSC_COMM_WORLD,&A);
 81:     MatSetSizes(A,PETSC_DECIDE,PETSC_DECIDE,0,0);
 82:     MatSetType(A,MATPYTHON);
 83:     MatPythonSetType(A,"ex140.py:Matrix");
 84:     /* default case, no user implementation */
 85:     for (i = 0; i < nop; i++) {
 86:       MatHasOperation(A,optenum[i],&hasop);
 87:       if (hasop) {
 88:         PetscPrintf(PETSC_COMM_WORLD,"  Error: %s present\n",optstr[i]);
 89:       } else {
 90:         PetscPrintf(PETSC_COMM_WORLD,"  Pass: %s\n",optstr[i]);
 91:       }
 92:     }
 93:     /* customize Matrix class at a later stage and add support for optenum[matop] */
 94:     PetscOptionsInsertString(NULL,opts);
 95:     MatSetFromOptions(A);
 96:     for (i = 0; i < nop; i++) {
 97:       MatHasOperation(A,optenum[i],&hasop);
 98:       if (hasop && i != matop) {
 99:         PetscPrintf(PETSC_COMM_WORLD,"  Error: %s present\n",optstr[i]);
100:       } else if (!hasop && i == matop) {
101:         PetscPrintf(PETSC_COMM_WORLD,"  Error: %s not present\n",optstr[i]);
102:       } else {
103:         PetscPrintf(PETSC_COMM_WORLD,"  Pass: %s\n",optstr[i]);
104:       }
105:     }
106:     MatDestroy(&A);
107:     PetscOptionsClearValue(NULL,opts);
108:   }
109:   return 0;
110: }

112: int main(int argc,char **argv)
113: {

115:   PetscInitialize(&argc,&argv,(char*) 0,help);
116:   PetscPythonInitialize(NULL,NULL);
117:   RunHasOperationTest();PetscPythonPrintError();
118:   PetscFinalize();
119:   return 0;
120: }

122: /*TEST

124:    test:
125:       requires: petsc4py
126:       localrunfiles: ex140.py

128: TEST*/