Actual source code: ex94.c

petsc-3.11.1 2019-04-12
Report Typos and Errors

  2: static char help[] = "Tests sequential and parallel MatMatMult() and MatPtAP(), MatTransposeMatMult(), sequential MatMatTransposeMult(), MatRARt()\n\
  3: Input arguments are:\n\
  4:   -f0 <input_file> -f1 <input_file> -f2 <input_file> -f3 <input_file> : file to load\n\n";
  5: /* Example of usage:
  6:    ./ex94 -f0 <A_binary> -f1 <B_binary> -matmatmult_mat_view ascii::ascii_info -matmatmulttr_mat_view
  7:    mpiexec -n 3 ./ex94 -f0 medium -f1 medium -f2 arco1 -f3 arco1 -matmatmult_mat_view
  8: */

 10:  #include <petscmat.h>

 12: /*
 13:      B = A - B
 14:      norm = norm(B)
 15: */
 16: PetscErrorCode MatNormDifference(Mat A,Mat B,PetscReal *norm)
 17: {

 21:   MatAXPY(B,-1.0,A,DIFFERENT_NONZERO_PATTERN);
 22:   MatNorm(B,NORM_FROBENIUS,norm);
 23:   return(0);
 24: }

 26: int main(int argc,char **args)
 27: {
 28:   Mat            A,A_save,B,P,R,C,C1;
 29:   Vec            x,v1,v2,v3,v4;
 30:   PetscViewer    viewer;
 32:   PetscMPIInt    size,rank;
 33:   PetscInt       i,m,n,j,*idxn,M,N,nzp,rstart,rend;
 34:   PetscReal      norm,norm_abs,norm_tmp,fill=4.0;
 35:   PetscRandom    rdm;
 36:   char           file[4][128];
 37:   PetscBool      flg,preload = PETSC_TRUE;
 38:   PetscScalar    *a,rval,alpha,none = -1.0;
 39:   PetscBool      Test_MatMatMult=PETSC_TRUE,Test_MatMatTr=PETSC_TRUE,Test_MatPtAP=PETSC_TRUE,Test_MatRARt=PETSC_TRUE,Test_MatMatMatMult=PETSC_TRUE;
 40:   PetscBool      Test_MatAXPY=PETSC_FALSE;
 41:   PetscInt       pm,pn,pM,pN;
 42:   MatInfo        info;
 43:   PetscBool      seqaij;
 44:   MatType        mattype;

 46:   PetscInitialize(&argc,&args,(char*)0,help);if (ierr) return ierr;
 47:   MPI_Comm_size(PETSC_COMM_WORLD,&size);
 48:   MPI_Comm_rank(PETSC_COMM_WORLD,&rank);

 50:   PetscOptionsGetReal(NULL,NULL,"-fill",&fill,NULL);

 52:   /*  Load the matrices A_save and B */
 53:   PetscOptionsGetString(NULL,NULL,"-f0",file[0],sizeof(file[0]),&flg);
 54:   if (!flg) SETERRQ(PETSC_COMM_WORLD,1,"Must indicate a file name for small matrix A with the -f0 option.");
 55:   PetscOptionsGetString(NULL,NULL,"-f1",file[1],sizeof(file[1]),&flg);
 56:   if (!flg) SETERRQ(PETSC_COMM_WORLD,1,"Must indicate a file name for small matrix B with the -f1 option.");
 57:   PetscOptionsGetString(NULL,NULL,"-f2",file[2],sizeof(file[2]),&flg);
 58:   if (!flg) {
 59:     preload = PETSC_FALSE;
 60:   } else {
 61:     PetscOptionsGetString(NULL,NULL,"-f3",file[3],128,&flg);
 62:     if (!flg) SETERRQ(PETSC_COMM_WORLD,1,"Must indicate a file name for test matrix B with the -f3 option.");
 63:   }

 65:   PetscPreLoadBegin(preload,"Load system");
 66:   PetscViewerBinaryOpen(PETSC_COMM_WORLD,file[2*PetscPreLoadIt],FILE_MODE_READ,&viewer);
 67:   MatCreate(PETSC_COMM_WORLD,&A_save);
 68:   MatSetFromOptions(A_save);
 69:   MatLoad(A_save,viewer);
 70:   PetscViewerDestroy(&viewer);

 72:   PetscViewerBinaryOpen(PETSC_COMM_WORLD,file[2*PetscPreLoadIt+1],FILE_MODE_READ,&viewer);
 73:   MatCreate(PETSC_COMM_WORLD,&B);
 74:   MatSetFromOptions(B);
 75:   MatLoad(B,viewer);
 76:   PetscViewerDestroy(&viewer);

 78:   MatGetType(B,&mattype);

 80:   MatGetSize(B,&M,&N);
 81:   nzp  = PetscMax((PetscInt)(0.1*M),5);
 82:   PetscMalloc((nzp+1)*(sizeof(PetscInt)+sizeof(PetscScalar)),&idxn);
 83:   a    = (PetscScalar*)(idxn + nzp);

 85:   /* Create vectors v1 and v2 that are compatible with A_save */
 86:   VecCreate(PETSC_COMM_WORLD,&v1);
 87:   MatGetLocalSize(A_save,&m,NULL);
 88:   VecSetSizes(v1,m,PETSC_DECIDE);
 89:   VecSetFromOptions(v1);
 90:   VecDuplicate(v1,&v2);

 92:   PetscRandomCreate(PETSC_COMM_WORLD,&rdm);
 93:   PetscRandomSetFromOptions(rdm);
 94:   PetscOptionsGetReal(NULL,NULL,"-fill",&fill,NULL);

 96:   /* Test MatAXPY()    */
 97:   /*-------------------*/
 98:   PetscOptionsHasName(NULL,NULL,"-test_MatAXPY",&Test_MatAXPY);
 99:   if (Test_MatAXPY) {
100:     Mat Btmp;
101:     MatDuplicate(A_save,MAT_COPY_VALUES,&A);
102:     MatDuplicate(B,MAT_COPY_VALUES,&Btmp);
103:     MatAXPY(A,-1.0,B,DIFFERENT_NONZERO_PATTERN); /* A = -B + A_save */

105:     MatScale(A,-1.0); /* A = -A = B - A_save */
106:     MatAXPY(Btmp,-1.0,A,DIFFERENT_NONZERO_PATTERN); /* Btmp = -A + B = A_save */
107:     MatMultEqual(A_save,Btmp,10,&flg);
108:     if (!flg) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_PLIB,"MatAXPY() is incorrect\n");
109:     MatDestroy(&A);
110:     MatDestroy(&Btmp);

112:     Test_MatMatMult    = PETSC_FALSE;
113:     Test_MatMatTr      = PETSC_FALSE;
114:     Test_MatPtAP       = PETSC_FALSE;
115:     Test_MatRARt       = PETSC_FALSE;
116:     Test_MatMatMatMult = PETSC_FALSE;
117:   }

119:   /* 1) Test MatMatMult() */
120:   /* ---------------------*/
121:   if (Test_MatMatMult) {
122:     MatDuplicate(A_save,MAT_COPY_VALUES,&A);
123:     MatMatMult(A,B,MAT_INITIAL_MATRIX,fill,&C);
124:     MatSetOptionsPrefix(C,"matmatmult_"); /* enable option '-matmatmult_' for matrix C */
125:     MatGetInfo(C,MAT_GLOBAL_SUM,&info);

127:     /* Test MAT_REUSE_MATRIX - reuse symbolic C */
128:     alpha=1.0;
129:     for (i=0; i<2; i++) {
130:       alpha -=0.1;
131:       MatScale(A,alpha);
132:       MatMatMult(A,B,MAT_REUSE_MATRIX,fill,&C);
133:     }
134:     MatMatMultEqual(A,B,C,10,&flg);
135:     if (!flg) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Error: MatMatMult()\n");
136:     MatDestroy(&A);

138:     /* Test MatDuplicate() of C=A*B */
139:     MatDuplicate(C,MAT_COPY_VALUES,&C1);
140:     MatDestroy(&C1);
141:     MatDestroy(&C);
142:   } /* if (Test_MatMatMult) */

144:   /* 2) Test MatTransposeMatMult() and MatMatTransposeMult() */
145:   /* ------------------------------------------------------- */
146:   if (Test_MatMatTr) {
147:     /* Create P */
148:     PetscInt PN,rstart,rend;
149:     PN   = M/2;
150:     nzp  = 5; /* num of nonzeros in each row of P */
151:     MatCreate(PETSC_COMM_WORLD,&P);
152:     MatSetSizes(P,PETSC_DECIDE,PETSC_DECIDE,M,PN);
153:     MatSetType(P,mattype);
154:     MatSeqAIJSetPreallocation(P,nzp,NULL);
155:     MatMPIAIJSetPreallocation(P,nzp,NULL,nzp,NULL);
156:     MatGetOwnershipRange(P,&rstart,&rend);
157:     for (i=0; i<nzp; i++) {
158:       PetscRandomGetValue(rdm,&a[i]);
159:     }
160:     for (i=rstart; i<rend; i++) {
161:       for (j=0; j<nzp; j++) {
162:         PetscRandomGetValue(rdm,&rval);
163:         idxn[j] = (PetscInt)(PetscRealPart(rval)*PN);
164:       }
165:       MatSetValues(P,1,&i,nzp,idxn,a,ADD_VALUES);
166:     }
167:     MatAssemblyBegin(P,MAT_FINAL_ASSEMBLY);
168:     MatAssemblyEnd(P,MAT_FINAL_ASSEMBLY);

170:     /* Create R = P^T */
171:     MatTranspose(P,MAT_INITIAL_MATRIX,&R);

173:     { /* Test R = P^T, C1 = R*B */
174:       MatMatMult(R,B,MAT_INITIAL_MATRIX,fill,&C1);
175:       MatTranspose(P,MAT_REUSE_MATRIX,&R);
176:       MatMatMult(R,B,MAT_REUSE_MATRIX,fill,&C1);
177:       MatDestroy(&C1);
178:     }

180:     /* C = P^T*B */
181:     MatTransposeMatMult(P,B,MAT_INITIAL_MATRIX,fill,&C);
182:     MatGetInfo(C,MAT_GLOBAL_SUM,&info);

184:     /* Test MAT_REUSE_MATRIX - reuse symbolic C */
185:     MatTransposeMatMult(P,B,MAT_REUSE_MATRIX,fill,&C);
186:     MatFreeIntermediateDataStructures(C);

188:     /* Compare P^T*B and R*B */
189:     MatMatMult(R,B,MAT_INITIAL_MATRIX,fill,&C1);
190:     MatNormDifference(C,C1,&norm);
191:     if (norm > PETSC_SMALL) SETERRQ1(PETSC_COMM_WORLD,PETSC_ERR_PLIB,"Error in MatTransposeMatMult(): %g\n",(double)norm);
192:     MatDestroy(&C1);

194:     /* Test MatDuplicate() of C=P^T*B */
195:     MatDuplicate(C,MAT_COPY_VALUES,&C1);
196:     MatDestroy(&C1);
197:     MatDestroy(&C);

199:     /* C = B*R^T */
200:     PetscObjectTypeCompare((PetscObject)B,MATSEQAIJ,&seqaij);
201:     if (size == 1 && seqaij) {
202:       MatMatTransposeMult(B,R,MAT_INITIAL_MATRIX,fill,&C);
203:       MatSetOptionsPrefix(C,"matmatmulttr_"); /* enable '-matmatmulttr_' for matrix C */
204:       MatGetInfo(C,MAT_GLOBAL_SUM,&info);

206:       /* Test MAT_REUSE_MATRIX - reuse symbolic C */
207:       MatMatTransposeMult(B,R,MAT_REUSE_MATRIX,fill,&C);

209:       /* Check */
210:       MatMatMult(B,P,MAT_INITIAL_MATRIX,fill,&C1);
211:       MatNormDifference(C,C1,&norm);
212:       if (norm > PETSC_SMALL) SETERRQ1(PETSC_COMM_WORLD,PETSC_ERR_PLIB,"Error in MatMatTransposeMult() %g\n",(double)norm);
213:       MatDestroy(&C1);
214:       MatDestroy(&C);
215:     }
216:     MatDestroy(&P);
217:     MatDestroy(&R);
218:   }

220:   /* 3) Test MatPtAP() */
221:   /*-------------------*/
222:   if (Test_MatPtAP) {
223:     PetscInt  PN;
224:     Mat       Cdup;
225:     PetscBool view=PETSC_FALSE;

227:     PetscOptionsGetBool(NULL,NULL,"-matptap_view",&view,NULL);
228:     MatDuplicate(A_save,MAT_COPY_VALUES,&A);
229:     MatGetSize(A,&M,&N);
230:     MatGetLocalSize(A,&m,&n);

232:     PN   = M/2;
233:     nzp  = (PetscInt)(0.1*PN+1); /* num of nozeros in each row of P */
234:     MatCreate(PETSC_COMM_WORLD,&P);
235:     MatSetSizes(P,PETSC_DECIDE,PETSC_DECIDE,N,PN);
236:     MatSetType(P,mattype);
237:     MatSeqAIJSetPreallocation(P,nzp,NULL);
238:     MatMPIAIJSetPreallocation(P,nzp,NULL,nzp,NULL);
239:     for (i=0; i<nzp; i++) {
240:       PetscRandomGetValue(rdm,&a[i]);
241:     }
242:     MatGetOwnershipRange(P,&rstart,&rend);
243:     for (i=rstart; i<rend; i++) {
244:       for (j=0; j<nzp; j++) {
245:         PetscRandomGetValue(rdm,&rval);
246:         idxn[j] = (PetscInt)(PetscRealPart(rval)*PN);
247:       }
248:       MatSetValues(P,1,&i,nzp,idxn,a,ADD_VALUES);
249:     }
250:     MatAssemblyBegin(P,MAT_FINAL_ASSEMBLY);
251:     MatAssemblyEnd(P,MAT_FINAL_ASSEMBLY);

253:     /* MatView(P,PETSC_VIEWER_STDOUT_WORLD); */
254:     MatGetSize(P,&pM,&pN);
255:     MatGetLocalSize(P,&pm,&pn);
256:     MatPtAP(A,P,MAT_INITIAL_MATRIX,fill,&C);

258:     /* Test MAT_REUSE_MATRIX - reuse symbolic C */
259:     alpha=1.0;
260:     for (i=0; i<2; i++) {
261:       alpha -=0.1;
262:       MatScale(A,alpha);
263:       MatPtAP(A,P,MAT_REUSE_MATRIX,fill,&C);
264:     }

266:     /* Test PtAP ops with P SeqDense and A either SeqAIJ or SeqDense (it assumes MatPtAP_SeqAIJ_SeqAIJ is fine) */
267:     if (size == 1) {
268:       Mat       Cdensetest,Pdense,Cdense,Adense;
269:       PetscReal norm;

271:       MatConvert(C,MATSEQDENSE,MAT_INITIAL_MATRIX,&Cdensetest);
272:       MatConvert(P,MATSEQDENSE,MAT_INITIAL_MATRIX,&Pdense);

274:       /* test with A SeqAIJ */
275:       PetscObjectTypeCompare((PetscObject)A,MATSEQAIJ,&seqaij);
276:       if (seqaij) {
277:         MatPtAP(A,Pdense,MAT_INITIAL_MATRIX,fill,&Cdense);
278:         MatAXPY(Cdense,-1.0,Cdensetest,SAME_NONZERO_PATTERN);
279:         MatNorm(Cdense,NORM_FROBENIUS,&norm);
280:         if (norm > PETSC_SMALL) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Error in MatPtAP with A SeqAIJ and P SeqDense: %g\n",(double)norm);
281:         MatScale(Cdense,-1.);
282:         MatPtAP(A,Pdense,MAT_REUSE_MATRIX,fill,&Cdense);
283:         MatAXPY(Cdense,-1.0,Cdensetest,SAME_NONZERO_PATTERN);
284:         MatNorm(Cdense,NORM_FROBENIUS,&norm);
285:         if (norm > PETSC_SMALL) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Error in MatPtAP with A SeqAIJ and P SeqDense and MAT_REUSE_MATRIX: %g\n",(double)norm);
286:         MatDestroy(&Cdense);
287:       }

289:       /* test with A SeqDense */
290:       MatConvert(A,MATSEQDENSE,MAT_INITIAL_MATRIX,&Adense);
291:       MatPtAP(Adense,Pdense,MAT_INITIAL_MATRIX,fill,&Cdense);
292:       MatAXPY(Cdense,-1.0,Cdensetest,SAME_NONZERO_PATTERN);
293:       MatNorm(Cdense,NORM_FROBENIUS,&norm);
294:       if (norm > PETSC_SMALL) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Error in MatPtAP with A SeqDense and P SeqDense: %g\n",(double)norm);
295:       MatScale(Cdense,-1.);
296:       MatPtAP(Adense,Pdense,MAT_REUSE_MATRIX,fill,&Cdense);
297:       MatAXPY(Cdense,-1.0,Cdensetest,SAME_NONZERO_PATTERN);
298:       MatNorm(Cdense,NORM_FROBENIUS,&norm);
299:       if (norm > PETSC_SMALL) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Error in MatPtAP with A SeqDense and P SeqDense and MAT_REUSE_MATRIX: %g\n",(double)norm);
300:       MatDestroy(&Cdense);
301:       MatDestroy(&Cdensetest);
302:       MatDestroy(&Pdense);
303:       MatDestroy(&Adense);
304:     }

306:     /* Test MatDuplicate() of C=PtAP and MatView(Cdup,...) */
307:     MatDuplicate(C,MAT_COPY_VALUES,&Cdup);
308:     if (view) {
309:       MatView(Cdup,PETSC_VIEWER_STDOUT_WORLD);
310:     }
311:     MatDestroy(&Cdup);

313:     if (size>1 || !seqaij) Test_MatRARt = PETSC_FALSE;
314:     /* 4) Test MatRARt() */
315:     /* ----------------- */
316:     if (Test_MatRARt) {
317:       Mat       R, RARt;
318:       MatTranspose(P,MAT_INITIAL_MATRIX,&R);
319:       MatRARt(A,R,MAT_INITIAL_MATRIX,2.0,&RARt);
320:       MatNormDifference(C,RARt,&norm);
321:       if (norm > PETSC_SMALL) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_PLIB,"|PtAP - RARt| = %g",(double)norm);
322:       MatDestroy(&R);
323:       MatDestroy(&RARt);
324:     }

326:     if (Test_MatMatMatMult && size == 1) {
327:       Mat       R, RAP;
328:       MatTranspose(P,MAT_INITIAL_MATRIX,&R);
329:       MatMatMatMult(R,A,P,MAT_INITIAL_MATRIX,2.0,&RAP);
330:       MatNormDifference(C,RAP,&norm);
331:       if (norm > PETSC_SMALL) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_PLIB,"PtAP != RAP %g",(double)norm);
332:       MatDestroy(&R);
333:       MatDestroy(&RAP);
334:     }

336:     /* Create vector x that is compatible with P */
337:     VecCreate(PETSC_COMM_WORLD,&x);
338:     MatGetLocalSize(P,&m,&n);
339:     VecSetSizes(x,n,PETSC_DECIDE);
340:     VecSetFromOptions(x);

342:     VecCreate(PETSC_COMM_WORLD,&v3);
343:     VecSetSizes(v3,n,PETSC_DECIDE);
344:     VecSetFromOptions(v3);
345:     VecDuplicate(v3,&v4);

347:     norm = 0.0;
348:     for (i=0; i<10; i++) {
349:       VecSetRandom(x,rdm);
350:       MatMult(P,x,v1);
351:       MatMult(A,v1,v2);  /* v2 = A*P*x */

353:       MatMultTranspose(P,v2,v3); /* v3 = Pt*A*P*x */
354:       MatMult(C,x,v4);           /* v3 = C*x   */
355:       VecNorm(v4,NORM_2,&norm_abs);
356:       VecAXPY(v4,none,v3);
357:       VecNorm(v4,NORM_2,&norm_tmp);

359:       norm_tmp /= norm_abs;
360:       if (norm_tmp > norm) norm = norm_tmp;
361:     }
362:     if (norm >= PETSC_SMALL) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Error: MatPtAP(), |v1 - v2|: %g\n",(double)norm);

364:     MatDestroy(&A);
365:     MatDestroy(&P);
366:     MatDestroy(&C);
367:     VecDestroy(&v3);
368:     VecDestroy(&v4);
369:     VecDestroy(&x);
370:   }

372:   /* Destroy objects */
373:   VecDestroy(&v1);
374:   VecDestroy(&v2);
375:   PetscRandomDestroy(&rdm);
376:   PetscFree(idxn);

378:   MatDestroy(&A_save);
379:   MatDestroy(&B);

381:   PetscPreLoadEnd();
382:   PetscFinalize();
383:   return ierr;
384: }



388: /*TEST

390:    test:
391:       suffix: 2_mattransposematmult_matmatmult
392:       nsize: 3
393:       requires: datafilespath !complex double !define(PETSC_USE_64BIT_INDICES)
394:       args: -f0 ${DATAFILESPATH}/matrices/medium -f1 ${DATAFILESPATH}/matrices/medium -mattransposematmult_via matmatmult> ex94_2.tmp 2>&1

396:    test:
397:       suffix: 2_mattransposematmult_scalable
398:       nsize: 3
399:       requires: datafilespath !complex double !define(PETSC_USE_64BIT_INDICES)
400:       args: -f0 ${DATAFILESPATH}/matrices/medium -f1 ${DATAFILESPATH}/matrices/medium -mattransposematmult_via scalable> ex94_2.tmp 2>&1
401:       output_file: output/ex94_1.out

403:    test:
404:       suffix: axpy_mpiaij
405:       requires: datafilespath !complex double !define(PETSC_USE_64BIT_INDICES)
406:       nsize: 8
407:       args: -f0 ${DATAFILESPATH}/matrices/poisson_2d5p -f1 ${DATAFILESPATH}/matrices/poisson_2d13p -test_MatAXPY
408:       output_file: output/ex94_1.out

410:    test:
411:       suffix: axpy_mpibaij
412:       requires: datafilespath !complex double !define(PETSC_USE_64BIT_INDICES)
413:       nsize: 8
414:       args: -f0 ${DATAFILESPATH}/matrices/poisson_2d5p -f1 ${DATAFILESPATH}/matrices/poisson_2d13p -test_MatAXPY -mat_type baij
415:       output_file: output/ex94_1.out

417:    test:
418:       suffix: axpy_mpisbaij
419:       requires: datafilespath !complex double !define(PETSC_USE_64BIT_INDICES)
420:       nsize: 8
421:       args: -f0 ${DATAFILESPATH}/matrices/poisson_2d5p -f1 ${DATAFILESPATH}/matrices/poisson_2d13p -test_MatAXPY -mat_type sbaij
422:       output_file: output/ex94_1.out

424:    test:
425:       suffix: matmatmult
426:       requires: datafilespath !complex double !define(PETSC_USE_64BIT_INDICES)
427:       args: -f0 ${DATAFILESPATH}/matrices/arco1 -f1 ${DATAFILESPATH}/matrices/arco1 -viewer_binary_skip_info
428:       output_file: output/ex94_1.out

430:    test:
431:       suffix: matmatmult_2
432:       requires: datafilespath !complex double !define(PETSC_USE_64BIT_INDICES)
433:       args: -f0 ${DATAFILESPATH}/matrices/arco1 -f1 ${DATAFILESPATH}/matrices/arco1 -mat_type mpiaij -viewer_binary_skip_info
434:       output_file: output/ex94_1.out

436:    test:
437:       suffix: matmatmult_scalable
438:       nsize: 4
439:       requires: datafilespath !complex double !define(PETSC_USE_64BIT_INDICES)
440:       args: -f0 ${DATAFILESPATH}/matrices/arco1 -f1 ${DATAFILESPATH}/matrices/arco1 -matmatmult_via scalable
441:       output_file: output/ex94_1.out

443:    test:
444:       suffix: ptap
445:       nsize: 3
446:       requires: datafilespath !complex double !define(PETSC_USE_64BIT_INDICES)
447:       args: -f0 ${DATAFILESPATH}/matrices/medium -f1 ${DATAFILESPATH}/matrices/medium -matptap_via scalable
448:       output_file: output/ex94_1.out

450:    test:
451:       suffix: rap
452:       nsize: 3
453:       requires: datafilespath !complex double !define(PETSC_USE_64BIT_INDICES)
454:       args: -f0 ${DATAFILESPATH}/matrices/medium -f1 ${DATAFILESPATH}/matrices/medium
455:       output_file: output/ex94_1.out

457:    test:
458:       suffix: scalable0
459:       requires: datafilespath !complex double !define(PETSC_USE_64BIT_INDICES)
460:       args: -f0 ${DATAFILESPATH}/matrices/arco1 -f1 ${DATAFILESPATH}/matrices/arco1 -viewer_binary_skip_info
461:       output_file: output/ex94_1.out

463:    test:
464:       suffix: scalable1
465:       requires: datafilespath !complex double !define(PETSC_USE_64BIT_INDICES)
466:       args: -f0 ${DATAFILESPATH}/matrices/arco1 -f1 ${DATAFILESPATH}/matrices/arco1 -viewer_binary_skip_info -matptap_via scalable
467:       output_file: output/ex94_1.out

469:    test:
470:       suffix: view
471:       nsize: 2
472:       requires: datafilespath !complex double !define(PETSC_USE_64BIT_INDICES)
473:       args: -f0 ${DATAFILESPATH}/matrices/tiny -f1 ${DATAFILESPATH}/matrices/tiny -viewer_binary_skip_info -matptap_view
474:       output_file: output/ex94_2.out

476: TEST*/