Actual source code: ex94.c

petsc-3.12.0 2019-09-29
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,AT,ATT,BT,BTT,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,view=PETSC_FALSE;
 41:   PetscInt       pm,pn,pM,pN;
 42:   MatInfo        info;
 43:   PetscBool      seqaij;
 44:   MatType        mattype;
 45:   Mat            Cdensetest,Pdense,Cdense,Adense;

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

 51:   PetscOptionsGetReal(NULL,NULL,"-fill",&fill,NULL);
 52:   PetscOptionsGetBool(NULL,NULL,"-matops_view",&view,NULL);
 53:   if (view) {
 54:     PetscViewerPushFormat(PETSC_VIEWER_STDOUT_WORLD,PETSC_VIEWER_ASCII_INFO);
 55:   }

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

 70:   PetscPreLoadBegin(preload,"Load system");
 71:   PetscViewerBinaryOpen(PETSC_COMM_WORLD,file[2*PetscPreLoadIt],FILE_MODE_READ,&viewer);
 72:   MatCreate(PETSC_COMM_WORLD,&A_save);
 73:   MatSetFromOptions(A_save);
 74:   MatLoad(A_save,viewer);
 75:   PetscViewerDestroy(&viewer);

 77:   PetscViewerBinaryOpen(PETSC_COMM_WORLD,file[2*PetscPreLoadIt+1],FILE_MODE_READ,&viewer);
 78:   MatCreate(PETSC_COMM_WORLD,&B);
 79:   MatSetFromOptions(B);
 80:   MatLoad(B,viewer);
 81:   PetscViewerDestroy(&viewer);

 83:   MatGetType(B,&mattype);

 85:   MatGetSize(B,&M,&N);
 86:   nzp  = PetscMax((PetscInt)(0.1*M),5);
 87:   PetscMalloc((nzp+1)*(sizeof(PetscInt)+sizeof(PetscScalar)),&idxn);
 88:   a    = (PetscScalar*)(idxn + nzp);

 90:   /* Create vectors v1 and v2 that are compatible with A_save */
 91:   VecCreate(PETSC_COMM_WORLD,&v1);
 92:   MatGetLocalSize(A_save,&m,NULL);
 93:   VecSetSizes(v1,m,PETSC_DECIDE);
 94:   VecSetFromOptions(v1);
 95:   VecDuplicate(v1,&v2);

 97:   PetscRandomCreate(PETSC_COMM_WORLD,&rdm);
 98:   PetscRandomSetFromOptions(rdm);
 99:   PetscOptionsGetReal(NULL,NULL,"-fill",&fill,NULL);

101:   /* Test MatAXPY()    */
102:   /*-------------------*/
103:   PetscOptionsHasName(NULL,NULL,"-test_MatAXPY",&Test_MatAXPY);
104:   if (Test_MatAXPY) {
105:     Mat Btmp;
106:     MatDuplicate(A_save,MAT_COPY_VALUES,&A);
107:     MatDuplicate(B,MAT_COPY_VALUES,&Btmp);
108:     MatAXPY(A,-1.0,B,DIFFERENT_NONZERO_PATTERN); /* A = -B + A_save */

110:     MatScale(A,-1.0); /* A = -A = B - A_save */
111:     MatAXPY(Btmp,-1.0,A,DIFFERENT_NONZERO_PATTERN); /* Btmp = -A + B = A_save */
112:     MatMultEqual(A_save,Btmp,10,&flg);
113:     if (!flg) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_PLIB,"MatAXPY() is incorrect\n");
114:     MatDestroy(&A);
115:     MatDestroy(&Btmp);

117:     Test_MatMatMult    = PETSC_FALSE;
118:     Test_MatMatTr      = PETSC_FALSE;
119:     Test_MatPtAP       = PETSC_FALSE;
120:     Test_MatRARt       = PETSC_FALSE;
121:     Test_MatMatMatMult = PETSC_FALSE;
122:   }

124:   /* 1) Test MatMatMult() */
125:   /* ---------------------*/
126:   if (Test_MatMatMult) {
127:     MatDuplicate(A_save,MAT_COPY_VALUES,&A);
128:     MatCreateTranspose(A,&AT);
129:     MatCreateTranspose(AT,&ATT);
130:     MatCreateTranspose(B,&BT);
131:     MatCreateTranspose(BT,&BTT);
132:     MatMatMult(ATT,B,MAT_INITIAL_MATRIX,fill,&C);
133:     MatMatMultEqual(A,B,C,10,&flg);
134:     if (!flg) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Error: MatMatMult()\n");
135:     MatDestroy(&C);
136:     MatMatMult(A,BTT,MAT_INITIAL_MATRIX,fill,&C);
137:     MatMatMultEqual(A,B,C,10,&flg);
138:     if (!flg) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Error: MatMatMult()\n");
139:     MatDestroy(&C);
140:     MatMatMult(ATT,BTT,MAT_INITIAL_MATRIX,fill,&C);
141:     MatMatMultEqual(A,B,C,10,&flg);
142:     if (!flg) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Error: MatMatMult()\n");
143:     MatDestroy(&C);
144:     MatDestroy(&BTT);
145:     MatDestroy(&BT);
146:     MatDestroy(&ATT);
147:     MatDestroy(&AT);
148:     MatMatMult(A,B,MAT_INITIAL_MATRIX,fill,&C);
149:     MatSetOptionsPrefix(C,"matmatmult_"); /* enable option '-matmatmult_' for matrix C */
150:     MatGetInfo(C,MAT_GLOBAL_SUM,&info);

152:     /* Test MAT_REUSE_MATRIX - reuse symbolic C */
153:     alpha=1.0;
154:     for (i=0; i<2; i++) {
155:       alpha -=0.1;
156:       MatScale(A,alpha);
157:       MatMatMult(A,B,MAT_REUSE_MATRIX,fill,&C);
158:     }
159:     MatMatMultEqual(A,B,C,10,&flg);
160:     if (!flg) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Error: MatMatMult()\n");
161:     MatDestroy(&A);

163:     /* Test MatDuplicate() of C=A*B */
164:     MatDuplicate(C,MAT_COPY_VALUES,&C1);
165:     MatDestroy(&C1);
166:     MatDestroy(&C);
167:   } /* if (Test_MatMatMult) */

169:   /* 2) Test MatTransposeMatMult() and MatMatTransposeMult() */
170:   /* ------------------------------------------------------- */
171:   if (Test_MatMatTr) {
172:     /* Create P */
173:     PetscInt PN,rstart,rend;
174:     PN   = M/2;
175:     nzp  = 5; /* num of nonzeros in each row of P */
176:     MatCreate(PETSC_COMM_WORLD,&P);
177:     MatSetSizes(P,PETSC_DECIDE,PETSC_DECIDE,M,PN);
178:     MatSetType(P,mattype);
179:     MatSeqAIJSetPreallocation(P,nzp,NULL);
180:     MatMPIAIJSetPreallocation(P,nzp,NULL,nzp,NULL);
181:     MatGetOwnershipRange(P,&rstart,&rend);
182:     for (i=0; i<nzp; i++) {
183:       PetscRandomGetValue(rdm,&a[i]);
184:     }
185:     for (i=rstart; i<rend; i++) {
186:       for (j=0; j<nzp; j++) {
187:         PetscRandomGetValue(rdm,&rval);
188:         idxn[j] = (PetscInt)(PetscRealPart(rval)*PN);
189:       }
190:       MatSetValues(P,1,&i,nzp,idxn,a,ADD_VALUES);
191:     }
192:     MatAssemblyBegin(P,MAT_FINAL_ASSEMBLY);
193:     MatAssemblyEnd(P,MAT_FINAL_ASSEMBLY);

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

198:     { /* Test R = P^T, C1 = R*B */
199:       MatMatMult(R,B,MAT_INITIAL_MATRIX,fill,&C1);
200:       MatTranspose(P,MAT_REUSE_MATRIX,&R);
201:       MatMatMult(R,B,MAT_REUSE_MATRIX,fill,&C1);
202:       MatDestroy(&C1);
203:     }

205:     /* C = P^T*B */
206:     MatTransposeMatMult(P,B,MAT_INITIAL_MATRIX,fill,&C);
207:     MatGetInfo(C,MAT_GLOBAL_SUM,&info);

209:     /* Test MAT_REUSE_MATRIX - reuse symbolic C */
210:     MatTransposeMatMult(P,B,MAT_REUSE_MATRIX,fill,&C);
211:     if (view) {
212:       PetscPrintf(PETSC_COMM_WORLD,"C = P^T * B:\n");
213:       MatView(C,PETSC_VIEWER_STDOUT_WORLD);
214:     }
215:     MatFreeIntermediateDataStructures(C);
216:     if (view) {
217:       PetscPrintf(PETSC_COMM_WORLD,"\nC = P^T * B after MatFreeIntermediateDataStructures():\n");
218:       MatView(C,PETSC_VIEWER_STDOUT_WORLD);
219:     }

221:     /* Compare P^T*B and R*B */
222:     MatMatMult(R,B,MAT_INITIAL_MATRIX,fill,&C1);
223:     MatNormDifference(C,C1,&norm);
224:     if (norm > PETSC_SMALL) SETERRQ1(PETSC_COMM_WORLD,PETSC_ERR_PLIB,"Error in MatTransposeMatMult(): %g\n",(double)norm);
225:     MatDestroy(&C1);

227:     /* Test MatDuplicate() of C=P^T*B */
228:     MatDuplicate(C,MAT_COPY_VALUES,&C1);
229:     MatDestroy(&C1);
230:     MatDestroy(&C);

232:     /* C = B*R^T */
233:     PetscObjectTypeCompare((PetscObject)B,MATSEQAIJ,&seqaij);
234:     if (size == 1 && seqaij) {
235:       MatMatTransposeMult(B,R,MAT_INITIAL_MATRIX,fill,&C);
236:       MatSetOptionsPrefix(C,"matmatmulttr_"); /* enable '-matmatmulttr_' for matrix C */
237:       MatGetInfo(C,MAT_GLOBAL_SUM,&info);

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

242:       /* Check */
243:       MatMatMult(B,P,MAT_INITIAL_MATRIX,fill,&C1);
244:       MatNormDifference(C,C1,&norm);
245:       if (norm > PETSC_SMALL) SETERRQ1(PETSC_COMM_WORLD,PETSC_ERR_PLIB,"Error in MatMatTransposeMult() %g\n",(double)norm);
246:       MatDestroy(&C1);
247:       MatDestroy(&C);
248:     }
249:     MatDestroy(&P);
250:     MatDestroy(&R);
251:   }

253:   /* 3) Test MatPtAP() */
254:   /*-------------------*/
255:   if (Test_MatPtAP) {
256:     PetscInt  PN;
257:     Mat       Cdup;

259:     MatDuplicate(A_save,MAT_COPY_VALUES,&A);
260:     MatGetSize(A,&M,&N);
261:     MatGetLocalSize(A,&m,&n);

263:     PN   = M/2;
264:     nzp  = (PetscInt)(0.1*PN+1); /* num of nozeros in each row of P */
265:     MatCreate(PETSC_COMM_WORLD,&P);
266:     MatSetSizes(P,PETSC_DECIDE,PETSC_DECIDE,N,PN);
267:     MatSetType(P,mattype);
268:     MatSeqAIJSetPreallocation(P,nzp,NULL);
269:     MatMPIAIJSetPreallocation(P,nzp,NULL,nzp,NULL);
270:     for (i=0; i<nzp; i++) {
271:       PetscRandomGetValue(rdm,&a[i]);
272:     }
273:     MatGetOwnershipRange(P,&rstart,&rend);
274:     for (i=rstart; i<rend; i++) {
275:       for (j=0; j<nzp; j++) {
276:         PetscRandomGetValue(rdm,&rval);
277:         idxn[j] = (PetscInt)(PetscRealPart(rval)*PN);
278:       }
279:       MatSetValues(P,1,&i,nzp,idxn,a,ADD_VALUES);
280:     }
281:     MatAssemblyBegin(P,MAT_FINAL_ASSEMBLY);
282:     MatAssemblyEnd(P,MAT_FINAL_ASSEMBLY);

284:     /* MatView(P,PETSC_VIEWER_STDOUT_WORLD); */
285:     MatGetSize(P,&pM,&pN);
286:     MatGetLocalSize(P,&pm,&pn);
287:     MatPtAP(A,P,MAT_INITIAL_MATRIX,fill,&C);

289:     /* Test MAT_REUSE_MATRIX - reuse symbolic C */
290:     alpha=1.0;
291:     for (i=0; i<2; i++) {
292:       alpha -=0.1;
293:       MatScale(A,alpha);
294:       MatPtAP(A,P,MAT_REUSE_MATRIX,fill,&C);
295:     }

297:     /* Test PtAP ops with P Dense and A either AIJ or SeqDense (it assumes MatPtAP_XAIJ_XAIJ is fine) */
298:     PetscObjectTypeCompare((PetscObject)A,MATSEQAIJ,&seqaij);
299:     if (seqaij) {
300:       MatConvert(C,MATSEQDENSE,MAT_INITIAL_MATRIX,&Cdensetest);
301:       MatConvert(P,MATSEQDENSE,MAT_INITIAL_MATRIX,&Pdense);
302:     } else {
303:       MatConvert(C,MATMPIDENSE,MAT_INITIAL_MATRIX,&Cdensetest);
304:       MatConvert(P,MATMPIDENSE,MAT_INITIAL_MATRIX,&Pdense);
305:     }

307:     /* test with A AIJ */
308:     MatPtAP(A,Pdense,MAT_INITIAL_MATRIX,fill,&Cdense);
309:     MatAXPY(Cdense,-1.0,Cdensetest,SAME_NONZERO_PATTERN);
310:     MatNorm(Cdense,NORM_FROBENIUS,&norm);
311:     if (norm > PETSC_SMALL) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Error in MatPtAP with A SeqAIJ and P SeqDense: %g\n",(double)norm);
312:     MatScale(Cdense,-1.);
313:     MatPtAP(A,Pdense,MAT_REUSE_MATRIX,fill,&Cdense);
314:     MatAXPY(Cdense,-1.0,Cdensetest,SAME_NONZERO_PATTERN);
315:     MatNorm(Cdense,NORM_FROBENIUS,&norm);
316:     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);
317:     MatDestroy(&Cdense);

319:     /* test with A SeqDense */
320:     if (seqaij) {
321:       MatConvert(A,MATSEQDENSE,MAT_INITIAL_MATRIX,&Adense);
322:       MatPtAP(Adense,Pdense,MAT_INITIAL_MATRIX,fill,&Cdense);
323:       MatAXPY(Cdense,-1.0,Cdensetest,SAME_NONZERO_PATTERN);
324:       MatNorm(Cdense,NORM_FROBENIUS,&norm);
325:       if (norm > PETSC_SMALL) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Error in MatPtAP with A SeqDense and P SeqDense: %g\n",(double)norm);
326:       MatScale(Cdense,-1.);
327:       MatPtAP(Adense,Pdense,MAT_REUSE_MATRIX,fill,&Cdense);
328:       MatAXPY(Cdense,-1.0,Cdensetest,SAME_NONZERO_PATTERN);
329:       MatNorm(Cdense,NORM_FROBENIUS,&norm);
330:       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);
331:       MatDestroy(&Cdense);
332:       MatDestroy(&Adense);
333:     }
334:     MatDestroy(&Cdensetest);
335:     MatDestroy(&Pdense);

337:     /* Test MatDuplicate() of C=PtAP and MatView(Cdup,...) */
338:     MatDuplicate(C,MAT_COPY_VALUES,&Cdup);
339:     if (view) {
340:       PetscPrintf(PETSC_COMM_WORLD,"\nC = P^T * A * P:\n");
341:       MatView(C,PETSC_VIEWER_STDOUT_WORLD);

343:       MatFreeIntermediateDataStructures(C);
344:       PetscPrintf(PETSC_COMM_WORLD,"\nC = P^T * A * P after MatFreeIntermediateDataStructures():\n");
345:       MatView(C,PETSC_VIEWER_STDOUT_WORLD);

347:       PetscPrintf(PETSC_COMM_WORLD,"\nCdup:\n");
348:       MatView(Cdup,PETSC_VIEWER_STDOUT_WORLD);
349:     }
350:     MatDestroy(&Cdup);

352:     if (size>1 || !seqaij) Test_MatRARt = PETSC_FALSE;
353:     /* 4) Test MatRARt() */
354:     /* ----------------- */
355:     if (Test_MatRARt) {
356:       Mat       R, RARt;
357:       MatTranspose(P,MAT_INITIAL_MATRIX,&R);
358:       MatRARt(A,R,MAT_INITIAL_MATRIX,2.0,&RARt);
359:       MatNormDifference(C,RARt,&norm);
360:       if (norm > PETSC_SMALL) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_PLIB,"|PtAP - RARt| = %g",(double)norm);
361:       MatDestroy(&R);
362:       MatDestroy(&RARt);
363:     }

365:     if (Test_MatMatMatMult && size == 1) {
366:       Mat       R, RAP;
367:       MatTranspose(P,MAT_INITIAL_MATRIX,&R);
368:       MatMatMatMult(R,A,P,MAT_INITIAL_MATRIX,2.0,&RAP);
369:       MatNormDifference(C,RAP,&norm);
370:       if (norm > PETSC_SMALL) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_PLIB,"PtAP != RAP %g",(double)norm);
371:       MatDestroy(&R);
372:       MatDestroy(&RAP);
373:     }

375:     /* Create vector x that is compatible with P */
376:     VecCreate(PETSC_COMM_WORLD,&x);
377:     MatGetLocalSize(P,&m,&n);
378:     VecSetSizes(x,n,PETSC_DECIDE);
379:     VecSetFromOptions(x);

381:     VecCreate(PETSC_COMM_WORLD,&v3);
382:     VecSetSizes(v3,n,PETSC_DECIDE);
383:     VecSetFromOptions(v3);
384:     VecDuplicate(v3,&v4);

386:     norm = 0.0;
387:     for (i=0; i<10; i++) {
388:       VecSetRandom(x,rdm);
389:       MatMult(P,x,v1);
390:       MatMult(A,v1,v2);  /* v2 = A*P*x */

392:       MatMultTranspose(P,v2,v3); /* v3 = Pt*A*P*x */
393:       MatMult(C,x,v4);           /* v3 = C*x   */
394:       VecNorm(v4,NORM_2,&norm_abs);
395:       VecAXPY(v4,none,v3);
396:       VecNorm(v4,NORM_2,&norm_tmp);

398:       norm_tmp /= norm_abs;
399:       if (norm_tmp > norm) norm = norm_tmp;
400:     }
401:     if (norm >= PETSC_SMALL) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Error: MatPtAP(), |v1 - v2|: %g\n",(double)norm);

403:     MatDestroy(&A);
404:     MatDestroy(&P);
405:     MatDestroy(&C);
406:     VecDestroy(&v3);
407:     VecDestroy(&v4);
408:     VecDestroy(&x);
409:   }

411:   /* Destroy objects */
412:   VecDestroy(&v1);
413:   VecDestroy(&v2);
414:   PetscRandomDestroy(&rdm);
415:   PetscFree(idxn);

417:   MatDestroy(&A_save);
418:   MatDestroy(&B);

420:   PetscPreLoadEnd();
421:   PetscFinalize();
422:   return ierr;
423: }



427: /*TEST

429:    test:
430:       suffix: 2_mattransposematmult_matmatmult
431:       nsize: 3
432:       requires: datafilespath !complex double !define(PETSC_USE_64BIT_INDICES)
433:       args: -f0 ${DATAFILESPATH}/matrices/medium -f1 ${DATAFILESPATH}/matrices/medium -mattransposematmult_via matmatmult> ex94_2.tmp 2>&1

435:    test:
436:       suffix: 2_mattransposematmult_scalable
437:       nsize: 3
438:       requires: datafilespath !complex double !define(PETSC_USE_64BIT_INDICES)
439:       args: -f0 ${DATAFILESPATH}/matrices/medium -f1 ${DATAFILESPATH}/matrices/medium -mattransposematmult_via scalable> ex94_2.tmp 2>&1
440:       output_file: output/ex94_1.out

442:    test:
443:       suffix: axpy_mpiaij
444:       requires: datafilespath !complex double !define(PETSC_USE_64BIT_INDICES)
445:       nsize: 8
446:       args: -f0 ${DATAFILESPATH}/matrices/poisson_2d5p -f1 ${DATAFILESPATH}/matrices/poisson_2d13p -test_MatAXPY
447:       output_file: output/ex94_1.out

449:    test:
450:       suffix: axpy_mpibaij
451:       requires: datafilespath !complex double !define(PETSC_USE_64BIT_INDICES)
452:       nsize: 8
453:       args: -f0 ${DATAFILESPATH}/matrices/poisson_2d5p -f1 ${DATAFILESPATH}/matrices/poisson_2d13p -test_MatAXPY -mat_type baij
454:       output_file: output/ex94_1.out

456:    test:
457:       suffix: axpy_mpisbaij
458:       requires: datafilespath !complex double !define(PETSC_USE_64BIT_INDICES)
459:       nsize: 8
460:       args: -f0 ${DATAFILESPATH}/matrices/poisson_2d5p -f1 ${DATAFILESPATH}/matrices/poisson_2d13p -test_MatAXPY -mat_type sbaij
461:       output_file: output/ex94_1.out

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

469:    test:
470:       suffix: matmatmult_2
471:       requires: datafilespath !complex double !define(PETSC_USE_64BIT_INDICES)
472:       args: -f0 ${DATAFILESPATH}/matrices/arco1 -f1 ${DATAFILESPATH}/matrices/arco1 -mat_type mpiaij -viewer_binary_skip_info
473:       output_file: output/ex94_1.out

475:    test:
476:       suffix: matmatmult_scalable
477:       nsize: 4
478:       requires: datafilespath !complex double !define(PETSC_USE_64BIT_INDICES)
479:       args: -f0 ${DATAFILESPATH}/matrices/arco1 -f1 ${DATAFILESPATH}/matrices/arco1 -matmatmult_via scalable
480:       output_file: output/ex94_1.out

482:    test:
483:       suffix: ptap
484:       nsize: 3
485:       requires: datafilespath !complex double !define(PETSC_USE_64BIT_INDICES)
486:       args: -f0 ${DATAFILESPATH}/matrices/medium -f1 ${DATAFILESPATH}/matrices/medium -matptap_via scalable
487:       output_file: output/ex94_1.out

489:    test:
490:       suffix: rap
491:       nsize: 3
492:       requires: datafilespath !complex double !define(PETSC_USE_64BIT_INDICES)
493:       args: -f0 ${DATAFILESPATH}/matrices/medium -f1 ${DATAFILESPATH}/matrices/medium
494:       output_file: output/ex94_1.out

496:    test:
497:       suffix: scalable0
498:       requires: datafilespath !complex double !define(PETSC_USE_64BIT_INDICES)
499:       args: -f0 ${DATAFILESPATH}/matrices/arco1 -f1 ${DATAFILESPATH}/matrices/arco1 -viewer_binary_skip_info
500:       output_file: output/ex94_1.out

502:    test:
503:       suffix: scalable1
504:       requires: datafilespath !complex double !define(PETSC_USE_64BIT_INDICES)
505:       args: -f0 ${DATAFILESPATH}/matrices/arco1 -f1 ${DATAFILESPATH}/matrices/arco1 -viewer_binary_skip_info -matptap_via scalable
506:       output_file: output/ex94_1.out

508:    test:
509:       suffix: view
510:       nsize: 2
511:       requires: datafilespath !complex double !define(PETSC_USE_64BIT_INDICES)
512:       args: -f0 ${DATAFILESPATH}/matrices/tiny -f1 ${DATAFILESPATH}/matrices/tiny -viewer_binary_skip_info -matops_view
513:       output_file: output/ex94_2.out

515: TEST*/