Actual source code: ex70.c

  1: #include <petscmat.h>

  3: static char help[] = "Tests MatMat operations with MAT_REUSE_MATRIX and already allocated dense result.\n\n";

  5: static PetscScalar MAGIC_NUMBER = 12345;

  7: static PetscErrorCode CheckLocal(Mat A, Mat B, PetscScalar *a, PetscScalar *b)
  8: {
  9:   PetscBool wA = PETSC_FALSE, wB = PETSC_FALSE;
 10:   PetscBool wAv = PETSC_FALSE, wBv = PETSC_FALSE;
 11:   PetscInt  lda, i, j, m, n;

 13:   PetscFunctionBegin;
 14:   if (a) {
 15:     const PetscScalar *Aa;
 16:     PetscCall(MatDenseGetArrayRead(A, &Aa));
 17:     wA = (PetscBool)(a != Aa);
 18:     PetscCall(MatDenseGetLDA(A, &lda));
 19:     PetscCall(MatGetLocalSize(A, &m, &n));
 20:     for (j = 0; j < n; j++) {
 21:       for (i = m; i < lda; i++) {
 22:         if (Aa[j * lda + i] != MAGIC_NUMBER) wAv = PETSC_TRUE;
 23:       }
 24:     }
 25:     PetscCall(MatDenseRestoreArrayRead(A, &Aa));
 26:   }
 27:   if (b) {
 28:     const PetscScalar *Bb;
 29:     PetscCall(MatDenseGetArrayRead(B, &Bb));
 30:     wB = (PetscBool)(b != Bb);
 31:     PetscCall(MatDenseGetLDA(B, &lda));
 32:     PetscCall(MatGetLocalSize(B, &m, &n));
 33:     for (j = 0; j < n; j++) {
 34:       for (i = m; i < lda; i++) {
 35:         if (Bb[j * lda + i] != MAGIC_NUMBER) wBv = PETSC_TRUE;
 36:       }
 37:     }
 38:     PetscCall(MatDenseRestoreArrayRead(B, &Bb));
 39:   }
 40:   PetscCheck(!wA && !wB, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Wrong array in first Mat? %d, Wrong array in second Mat? %d", wA, wB);
 41:   PetscCheck(!wAv && !wBv, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Wrong data in first Mat? %d, Wrong data in second Mat? %d", wAv, wBv);
 42:   PetscFunctionReturn(PETSC_SUCCESS);
 43: }

 45: typedef struct {
 46:   Mat A;
 47:   Mat P;
 48:   Mat R;
 49: } proj_data;

 51: PetscErrorCode proj_destroy(PetscCtxRt ctx)
 52: {
 53:   proj_data *userdata = *(proj_data **)ctx;

 55:   PetscFunctionBegin;
 56:   PetscCheck(userdata, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Missing userdata");
 57:   PetscCall(MatDestroy(&userdata->A));
 58:   PetscCall(MatDestroy(&userdata->P));
 59:   PetscCall(MatDestroy(&userdata->R));
 60:   PetscCall(PetscFree(userdata));
 61:   PetscFunctionReturn(PETSC_SUCCESS);
 62: }

 64: PetscErrorCode proj_mult(Mat S, Vec X, Vec Y)
 65: {
 66:   Mat        A, R, P;
 67:   Vec        Ax, Ay;
 68:   Vec        Px, Py;
 69:   proj_data *userdata;

 71:   PetscFunctionBegin;
 72:   PetscCall(MatShellGetContext(S, &userdata));
 73:   PetscCheck(userdata, PetscObjectComm((PetscObject)S), PETSC_ERR_PLIB, "Missing userdata");
 74:   A = userdata->A;
 75:   R = userdata->R;
 76:   P = userdata->P;
 77:   PetscCheck(A, PetscObjectComm((PetscObject)S), PETSC_ERR_PLIB, "Missing matrix");
 78:   PetscCheck(R || P, PetscObjectComm((PetscObject)S), PETSC_ERR_PLIB, "Missing projectors");
 79:   PetscCheck(!R || !P, PetscObjectComm((PetscObject)S), PETSC_ERR_PLIB, "Both projectors");
 80:   PetscCall(MatCreateVecs(A, &Ax, &Ay));
 81:   if (R) PetscCall(MatCreateVecs(R, &Py, &Px));
 82:   else PetscCall(MatCreateVecs(P, &Px, &Py));
 83:   PetscCall(VecCopy(X, Px));
 84:   if (P) PetscCall(MatMult(P, Px, Py));
 85:   else PetscCall(MatMultTranspose(R, Px, Py));
 86:   PetscCall(VecCopy(Py, Ax));
 87:   PetscCall(MatMult(A, Ax, Ay));
 88:   PetscCall(VecCopy(Ay, Py));
 89:   if (P) PetscCall(MatMultTranspose(P, Py, Px));
 90:   else PetscCall(MatMult(R, Py, Px));
 91:   PetscCall(VecCopy(Px, Y));
 92:   PetscCall(VecDestroy(&Px));
 93:   PetscCall(VecDestroy(&Py));
 94:   PetscCall(VecDestroy(&Ax));
 95:   PetscCall(VecDestroy(&Ay));
 96:   PetscFunctionReturn(PETSC_SUCCESS);
 97: }

 99: PetscErrorCode MyPtShellPMultSymbolic(Mat S, Mat P, Mat PtAP, void **ctx)
100: {
101:   proj_data *userdata;

103:   PetscFunctionBegin;
104:   PetscCall(PetscNew(&userdata));
105:   PetscCall(MatShellSetContext(PtAP, userdata));
106:   *ctx = (void *)userdata;
107:   PetscFunctionReturn(PETSC_SUCCESS);
108: }

110: PetscErrorCode MyPtShellPMultNumeric(Mat S, Mat P, Mat PtAP, PetscCtx ctx)
111: {
112:   Mat        A;
113:   proj_data *userdata = (proj_data *)ctx;

115:   PetscFunctionBegin;
116:   PetscCall(MatShellGetContext(S, &A));
117:   PetscCall(PetscObjectReference((PetscObject)A));
118:   PetscCall(PetscObjectReference((PetscObject)P));
119:   PetscCall(MatDestroy(&userdata->A));
120:   PetscCall(MatDestroy(&userdata->P));
121:   PetscCall(MatDestroy(&userdata->R));
122:   userdata->A = A;
123:   userdata->P = P;
124:   PetscCall(MatShellSetOperation(PtAP, MATOP_MULT, (PetscErrorCodeFn *)proj_mult));
125:   PetscCall(MatSetUp(PtAP));
126:   PetscCall(MatAssemblyBegin(PtAP, MAT_FINAL_ASSEMBLY));
127:   PetscCall(MatAssemblyEnd(PtAP, MAT_FINAL_ASSEMBLY));
128:   PetscFunctionReturn(PETSC_SUCCESS);
129: }

131: PetscErrorCode MyRShellRtMultSymbolic(Mat S, Mat R, Mat RARt, void **ctx)
132: {
133:   proj_data *userdata;

135:   PetscFunctionBegin;
136:   PetscCall(PetscNew(&userdata));
137:   PetscCall(MatShellSetContext(RARt, userdata));
138:   *ctx = (void *)userdata;
139:   PetscFunctionReturn(PETSC_SUCCESS);
140: }

142: PetscErrorCode MyRShellRtMultNumeric(Mat S, Mat R, Mat RARt, PetscCtx ctx)
143: {
144:   Mat        A;
145:   proj_data *userdata = (proj_data *)ctx;

147:   PetscFunctionBegin;
148:   PetscCall(MatShellGetContext(S, &A));
149:   PetscCall(PetscObjectReference((PetscObject)A));
150:   PetscCall(PetscObjectReference((PetscObject)R));
151:   PetscCall(MatDestroy(&userdata->A));
152:   PetscCall(MatDestroy(&userdata->P));
153:   PetscCall(MatDestroy(&userdata->R));
154:   userdata->A = A;
155:   userdata->R = R;
156:   PetscCall(MatShellSetOperation(RARt, MATOP_MULT, (PetscErrorCodeFn *)proj_mult));
157:   PetscCall(MatSetUp(RARt));
158:   PetscCall(MatAssemblyBegin(RARt, MAT_FINAL_ASSEMBLY));
159:   PetscCall(MatAssemblyEnd(RARt, MAT_FINAL_ASSEMBLY));
160:   PetscFunctionReturn(PETSC_SUCCESS);
161: }

163: PetscErrorCode MyMatShellMatMultNumeric(Mat S, Mat B, Mat C, PetscCtx ctx)
164: {
165:   Mat A;

167:   PetscFunctionBegin;
168:   PetscCall(MatShellGetContext(S, &A));
169:   PetscCall(MatMatMult(A, B, MAT_REUSE_MATRIX, PETSC_DETERMINE, &C));
170:   PetscFunctionReturn(PETSC_SUCCESS);
171: }

173: PetscErrorCode MyMatTransposeShellMatMultNumeric(Mat S, Mat B, Mat C, PetscCtx ctx)
174: {
175:   Mat A;

177:   PetscFunctionBegin;
178:   PetscCall(MatShellGetContext(S, &A));
179:   PetscCall(MatTransposeMatMult(A, B, MAT_REUSE_MATRIX, PETSC_DETERMINE, &C));
180:   PetscFunctionReturn(PETSC_SUCCESS);
181: }

183: PetscErrorCode MyMatShellMatTransposeMultNumeric(Mat S, Mat B, Mat C, PetscCtx ctx)
184: {
185:   Mat A;

187:   PetscFunctionBegin;
188:   PetscCall(MatShellGetContext(S, &A));
189:   PetscCall(MatMatTransposeMult(A, B, MAT_REUSE_MATRIX, PETSC_DETERMINE, &C));
190:   PetscFunctionReturn(PETSC_SUCCESS);
191: }

193: int main(int argc, char **args)
194: {
195:   Mat          X, B, A, Bt, T, T2, PtAP = NULL, RARt = NULL, R = NULL;
196:   Vec          r, l, rs, ls;
197:   PetscInt     m, n, k, M = 10, N = 10, K = 5, ldx = 3, ldb = 5, ldr = 4;
198:   char         mattype[256];
199:   PetscBool    flg, symm = PETSC_FALSE, testtt = PETSC_TRUE, testnest = PETSC_TRUE, testtranspose = PETSC_TRUE, testcircular = PETSC_FALSE, local = PETSC_TRUE;
200:   PetscBool    testhtranspose = PETSC_FALSE; /* Hermitian transpose is not handled correctly and generates an error */
201:   PetscBool    xgpu = PETSC_FALSE, bgpu = PETSC_FALSE, testshellops = PETSC_FALSE, testproj = PETSC_TRUE, testrart = PETSC_TRUE, testmatmatt = PETSC_TRUE, testmattmat = PETSC_TRUE, formt = PETSC_FALSE, testreusemodified = PETSC_FALSE;
202:   PetscScalar *dataX = NULL, *dataB = NULL, *dataR = NULL, *dataBt = NULL;
203:   PetscScalar *aX, *aB, *aBt;
204:   PetscReal    err;

206:   PetscFunctionBeginUser;
207:   PetscCall(PetscInitialize(&argc, &args, NULL, help));
208:   PetscCall(PetscOptionsGetInt(NULL, NULL, "-N", &N, NULL));
209:   PetscCall(PetscOptionsGetInt(NULL, NULL, "-M", &M, NULL));
210:   PetscCall(PetscOptionsGetInt(NULL, NULL, "-K", &K, NULL));
211:   PetscCall(PetscOptionsGetBool(NULL, NULL, "-symm", &symm, NULL));
212:   PetscCall(PetscOptionsGetBool(NULL, NULL, "-local", &local, NULL));
213:   PetscCall(PetscOptionsGetInt(NULL, NULL, "-ldx", &ldx, NULL));
214:   PetscCall(PetscOptionsGetInt(NULL, NULL, "-ldb", &ldb, NULL));
215:   PetscCall(PetscOptionsGetInt(NULL, NULL, "-ldr", &ldr, NULL));
216:   PetscCall(PetscOptionsGetBool(NULL, NULL, "-testtranspose", &testtranspose, NULL));
217:   PetscCall(PetscOptionsGetBool(NULL, NULL, "-testnest", &testnest, NULL));
218:   PetscCall(PetscOptionsGetBool(NULL, NULL, "-testtt", &testtt, NULL));
219:   PetscCall(PetscOptionsGetBool(NULL, NULL, "-testcircular", &testcircular, NULL));
220:   PetscCall(PetscOptionsGetBool(NULL, NULL, "-testshellops", &testshellops, NULL));
221:   PetscCall(PetscOptionsGetBool(NULL, NULL, "-testproj", &testproj, NULL));
222:   PetscCall(PetscOptionsGetBool(NULL, NULL, "-testrart", &testrart, NULL));
223:   PetscCall(PetscOptionsGetBool(NULL, NULL, "-testmatmatt", &testmatmatt, NULL));
224:   PetscCall(PetscOptionsGetBool(NULL, NULL, "-testmattmat", &testmattmat, NULL));
225:   PetscCall(PetscOptionsGetBool(NULL, NULL, "-xgpu", &xgpu, NULL));
226:   PetscCall(PetscOptionsGetBool(NULL, NULL, "-bgpu", &bgpu, NULL));
227:   PetscCall(PetscOptionsGetBool(NULL, NULL, "-A_form_explicit_transpose", &formt, NULL));
228:   PetscCall(PetscOptionsGetBool(NULL, NULL, "-testreusemodified", &testreusemodified, NULL));
229:   PetscCall(PetscOptionsGetScalar(NULL, NULL, "-magic_number", &MAGIC_NUMBER, NULL));
230:   if (M != N) testproj = PETSC_FALSE;

232:   PetscCall(MatCreate(PETSC_COMM_WORLD, &A));
233:   PetscCall(MatSetSizes(A, PETSC_DECIDE, PETSC_DECIDE, M, N));
234:   PetscCall(MatSetType(A, MATAIJ));
235:   PetscCall(MatSeqAIJSetPreallocation(A, PETSC_DEFAULT, NULL));
236:   PetscCall(MatMPIAIJSetPreallocation(A, PETSC_DEFAULT, NULL, PETSC_DEFAULT, NULL));
237:   PetscCall(MatSetUp(A));
238:   PetscCall(MatSetRandom(A, NULL));
239:   if (M == N && symm) {
240:     Mat AT;

242:     PetscCall(MatTranspose(A, MAT_INITIAL_MATRIX, &AT));
243:     PetscCall(MatAXPY(A, 1.0, AT, DIFFERENT_NONZERO_PATTERN));
244:     PetscCall(MatDestroy(&AT));
245:     PetscCall(MatSetOption(A, MAT_SYMMETRIC, PETSC_TRUE));
246:   }
247:   PetscCall(MatViewFromOptions(A, NULL, "-A_init_view"));
248:   PetscOptionsBegin(PETSC_COMM_WORLD, "", "", "");
249:   PetscCall(PetscOptionsFList("-A_mat_type", "Matrix type", "MatSetType", MatList, MATAIJ, mattype, sizeof(mattype), &flg));
250:   PetscOptionsEnd();
251:   if (flg) {
252:     Mat A2;

254:     PetscCall(MatDuplicate(A, MAT_COPY_VALUES, &A2));
255:     PetscCall(MatConvert(A, mattype, MAT_INPLACE_MATRIX, &A));
256:     PetscCall(MatMultEqual(A, A2, 10, &flg));
257:     if (!flg) {
258:       Mat AE, A2E;

260:       PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with convert\n"));
261:       PetscCall(MatComputeOperator(A, MATDENSE, &AE));
262:       PetscCall(MatComputeOperator(A2, MATDENSE, &A2E));
263:       PetscCall(MatView(AE, NULL));
264:       PetscCall(MatView(A2E, NULL));
265:       PetscCall(MatAXPY(A2E, -1.0, A, SAME_NONZERO_PATTERN));
266:       PetscCall(MatView(A2E, NULL));
267:       PetscCall(MatDestroy(&A2E));
268:       PetscCall(MatDestroy(&AE));
269:     }
270:     PetscCall(MatDestroy(&A2));
271:   }
272:   if (formt) PetscCall(MatSetOption(A, MAT_FORM_EXPLICIT_TRANSPOSE, PETSC_TRUE));
273:   PetscCall(MatViewFromOptions(A, NULL, "-A_view"));

275:   PetscCall(MatGetLocalSize(A, &m, &n));
276:   if (local) {
277:     PetscCall(PetscMalloc1((m + ldx) * K, &dataX));
278:     PetscCall(PetscMalloc1((n + ldb) * K, &dataB));
279:     for (PetscInt i = 0; i < (m + ldx) * K; i++) dataX[i] = MAGIC_NUMBER;
280:     for (PetscInt i = 0; i < (n + ldb) * K; i++) dataB[i] = MAGIC_NUMBER;
281:   }
282:   PetscCall(MatCreateDense(PETSC_COMM_WORLD, n, PETSC_DECIDE, N, K, dataB, &B));
283:   PetscCall(MatCreateDense(PETSC_COMM_WORLD, m, PETSC_DECIDE, M, K, dataX, &X));
284:   if (local) {
285:     PetscCall(MatDenseSetLDA(X, m + ldx));
286:     PetscCall(MatDenseSetLDA(B, n + ldb));
287:   }
288:   PetscCall(MatGetLocalSize(B, NULL, &k));
289:   if (local) {
290:     PetscCall(PetscMalloc1((k + ldr) * N, &dataBt));
291:     for (PetscInt i = 0; i < (k + ldr) * N; i++) dataBt[i] = MAGIC_NUMBER;
292:   }
293:   PetscCall(MatCreateDense(PETSC_COMM_WORLD, k, n, K, N, dataBt, &Bt));
294:   if (local) PetscCall(MatDenseSetLDA(Bt, k + ldr));

296:   /* store pointer to dense data for testing */
297:   PetscCall(MatDenseGetArrayRead(B, (const PetscScalar **)&dataB));
298:   PetscCall(MatDenseGetArrayRead(X, (const PetscScalar **)&dataX));
299:   PetscCall(MatDenseGetArrayRead(Bt, (const PetscScalar **)&dataBt));
300:   aX  = dataX;
301:   aB  = dataB;
302:   aBt = dataBt;
303:   PetscCall(MatDenseRestoreArrayRead(Bt, (const PetscScalar **)&dataBt));
304:   PetscCall(MatDenseRestoreArrayRead(B, (const PetscScalar **)&dataB));
305:   PetscCall(MatDenseRestoreArrayRead(X, (const PetscScalar **)&dataX));
306:   if (local) {
307:     dataX  = aX;
308:     dataB  = aB;
309:     dataBt = aBt;
310:   }

312:   PetscCall(MatSetRandom(X, NULL));
313:   PetscCall(MatSetRandom(B, NULL));
314:   PetscCall(MatSetRandom(Bt, NULL));
315:   PetscCall(CheckLocal(X, NULL, aX, NULL));
316:   PetscCall(CheckLocal(Bt, B, aBt, aB));

318:   /* convert to CUDA if needed */
319:   if (bgpu) {
320:     PetscCall(MatConvert(B, MATDENSECUDA, MAT_INPLACE_MATRIX, &B));
321:     PetscCall(MatConvert(Bt, MATDENSECUDA, MAT_INPLACE_MATRIX, &Bt));
322:   }
323:   if (xgpu) PetscCall(MatConvert(X, MATDENSECUDA, MAT_INPLACE_MATRIX, &X));
324:   PetscCall(CheckLocal(B, X, aB, aX));

326:   /* Test MatDenseGetSubMatrix */
327:   {
328:     Mat B2, T3, T4;

330:     PetscCall(MatDuplicate(B, MAT_COPY_VALUES, &B2));
331:     PetscCall(MatDuplicate(B, MAT_DO_NOT_COPY_VALUES, &T4));
332:     PetscCall(MatSetRandom(T4, NULL));
333:     PetscCall(MatAXPY(B2, 1.0, T4, SAME_NONZERO_PATTERN));
334:     PetscCall(MatDenseGetSubMatrix(B, PETSC_DECIDE, PETSC_DECIDE, PetscMin(1, K - 1), PetscMin(2, K), &T));
335:     PetscCall(MatDenseGetSubMatrix(T4, PETSC_DECIDE, PETSC_DECIDE, PetscMin(1, K - 1), PetscMin(2, K), &T2));
336:     PetscCall(MatDenseGetSubMatrix(B2, PETSC_DECIDE, PETSC_DECIDE, PetscMin(1, K - 1), PetscMin(2, K), &T3));
337:     PetscCall(MatAXPY(T, 1.0, T2, SAME_NONZERO_PATTERN));
338:     PetscCall(MatAXPY(T3, -1.0, T, SAME_NONZERO_PATTERN));
339:     PetscCall(MatNorm(T3, NORM_FROBENIUS, &err));
340:     if (err > PETSC_SMALL) {
341:       PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with MatDenseGetSubMatrix\n"));
342:       PetscCall(MatView(T3, NULL));
343:     }
344:     PetscCall(MatDenseRestoreSubMatrix(B, &T));
345:     PetscCall(MatDenseRestoreSubMatrix(T4, &T2));
346:     PetscCall(MatDenseRestoreSubMatrix(B2, &T3));
347:     PetscCall(CheckLocal(B, NULL, aB, NULL));
348:     PetscCall(MatDestroy(&B2));
349:     PetscCall(MatDestroy(&T4));
350:     if (N >= 2) {
351:       PetscCall(MatDuplicate(B, MAT_COPY_VALUES, &B2));
352:       PetscCall(MatDuplicate(B, MAT_DO_NOT_COPY_VALUES, &T4));
353:       PetscCall(MatSetRandom(T4, NULL));
354:       PetscCall(MatAXPY(B2, 1.0, T4, SAME_NONZERO_PATTERN));
355:       PetscCall(MatDenseGetSubMatrix(B, N - 2, PETSC_DECIDE, PetscMin(1, K - 1), PetscMin(2, K), &T));
356:       PetscCall(MatDenseGetSubMatrix(T4, N - 2, PETSC_DECIDE, PetscMin(1, K - 1), PetscMin(2, K), &T2));
357:       PetscCall(MatDenseGetSubMatrix(B2, N - 2, PETSC_DECIDE, PetscMin(1, K - 1), PetscMin(2, K), &T3));
358:       PetscCall(MatAXPY(T, 1.0, T2, SAME_NONZERO_PATTERN));
359:       PetscCall(MatAXPY(T3, -1.0, T, SAME_NONZERO_PATTERN));
360:       PetscCall(MatNorm(T3, NORM_FROBENIUS, &err));
361:       if (err > PETSC_SMALL) {
362:         PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with MatDenseGetSubMatrix\n"));
363:         PetscCall(MatView(T3, NULL));
364:       }
365:       PetscCall(MatDenseRestoreSubMatrix(B, &T));
366:       PetscCall(MatDenseRestoreSubMatrix(T4, &T2));
367:       PetscCall(MatDenseRestoreSubMatrix(B2, &T3));
368:       PetscCall(CheckLocal(B, NULL, aB, NULL));
369:       PetscCall(MatDestroy(&B2));
370:       PetscCall(MatDestroy(&T4));
371:       PetscCall(MatDuplicate(B, MAT_COPY_VALUES, &B2));
372:       PetscCall(MatDuplicate(B, MAT_DO_NOT_COPY_VALUES, &T4));
373:       PetscCall(MatSetRandom(T4, NULL));
374:       PetscCall(MatAXPY(B2, 1.0, T4, SAME_NONZERO_PATTERN));
375:       PetscCall(MatDenseGetSubMatrix(B, PETSC_DECIDE, 2, PetscMin(1, K - 1), PetscMin(2, K), &T));
376:       PetscCall(MatDenseGetSubMatrix(T4, PETSC_DECIDE, 2, PetscMin(1, K - 1), PetscMin(2, K), &T2));
377:       PetscCall(MatDenseGetSubMatrix(B2, PETSC_DECIDE, 2, PetscMin(1, K - 1), PetscMin(2, K), &T3));
378:       PetscCall(MatAXPY(T, 1.0, T2, SAME_NONZERO_PATTERN));
379:       PetscCall(MatAXPY(T3, -1.0, T, SAME_NONZERO_PATTERN));
380:       PetscCall(MatNorm(T3, NORM_FROBENIUS, &err));
381:       if (err > PETSC_SMALL) {
382:         PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with MatDenseGetSubMatrix\n"));
383:         PetscCall(MatView(T3, NULL));
384:       }
385:       PetscCall(MatDenseRestoreSubMatrix(B, &T));
386:       PetscCall(MatDenseRestoreSubMatrix(T4, &T2));
387:       PetscCall(MatDenseRestoreSubMatrix(B2, &T3));
388:       PetscCall(CheckLocal(B, NULL, aB, NULL));
389:       PetscCall(MatDestroy(&B2));
390:       PetscCall(MatDestroy(&T4));
391:     }
392:   }

394:   /* Test reusing a previously allocated dense buffer */
395:   PetscCall(MatMatMult(A, B, MAT_REUSE_MATRIX, PETSC_DETERMINE, &X));
396:   PetscCall(CheckLocal(B, X, aB, aX));
397:   PetscCall(MatMatMultEqual(A, B, X, 10, &flg));
398:   if (!flg) {
399:     PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with reusage\n"));
400:     PetscCall(MatMatMult(A, B, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &T));
401:     PetscCall(MatAXPY(T, -1.0, X, SAME_NONZERO_PATTERN));
402:     PetscCall(MatView(T, NULL));
403:     PetscCall(MatDestroy(&T));
404:   }

406:   /* Test MatTransposeMat and MatMatTranspose */
407:   if (testmattmat) {
408:     PetscCall(MatTransposeMatMult(A, X, MAT_REUSE_MATRIX, PETSC_DETERMINE, &B));
409:     PetscCall(CheckLocal(B, X, aB, aX));
410:     PetscCall(MatTransposeMatMultEqual(A, X, B, 10, &flg));
411:     if (!flg) {
412:       PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with reusage (MatTransposeMat)\n"));
413:       PetscCall(MatTransposeMatMult(A, X, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &B));
414:       PetscCall(MatAXPY(T, -1.0, B, SAME_NONZERO_PATTERN));
415:       PetscCall(MatView(T, NULL));
416:       PetscCall(MatDestroy(&T));
417:     }
418:   }
419:   if (testmatmatt) {
420:     PetscCall(MatMatTransposeMult(A, Bt, MAT_REUSE_MATRIX, PETSC_DETERMINE, &X));
421:     PetscCall(CheckLocal(Bt, X, aBt, aX));
422:     PetscCall(MatMatTransposeMultEqual(A, Bt, X, 10, &flg));
423:     if (!flg) {
424:       PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with reusage (MatMatTranspose)\n"));
425:       PetscCall(MatMatTransposeMult(A, Bt, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &T));
426:       PetscCall(MatAXPY(T, -1.0, X, SAME_NONZERO_PATTERN));
427:       PetscCall(MatView(T, NULL));
428:       PetscCall(MatDestroy(&T));
429:     }
430:   }

432:   /* Test that MAT_REUSE_MATRIX uses the current values of A after they change, and uses another matrix A2 when given one */
433:   if (testreusemodified) {
434:     Mat E, A2;

436:     PetscCall(MatTransposeMatMult(A, X, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &E));
437:     PetscCall(MatScale(A, 2.0));
438:     PetscCall(MatTransposeMatMult(A, X, MAT_REUSE_MATRIX, PETSC_DETERMINE, &E));
439:     PetscCall(MatTransposeMatMultEqual(A, X, E, 10, &flg));
440:     if (!flg) PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with reusage after MatScale() (MatTransposeMat)\n"));
441:     PetscCall(MatScale(A, 0.5));
442:     PetscCall(MatDuplicate(A, MAT_COPY_VALUES, &A2));
443:     PetscCall(MatScale(A2, 3.0));
444:     PetscCall(MatTransposeMatMult(A2, X, MAT_REUSE_MATRIX, PETSC_DETERMINE, &E));
445:     PetscCall(MatTransposeMatMultEqual(A2, X, E, 10, &flg));
446:     if (!flg) PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with reusage with another A (MatTransposeMat)\n"));
447:     PetscCall(MatDestroy(&E));
448:     if (testmatmatt) {
449:       PetscCall(MatMatTransposeMult(A, Bt, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &E));
450:       PetscCall(MatMatTransposeMult(A2, Bt, MAT_REUSE_MATRIX, PETSC_DETERMINE, &E));
451:       PetscCall(MatMatTransposeMultEqual(A2, Bt, E, 10, &flg));
452:       if (!flg) PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with reusage with another A (MatMatTranspose)\n"));
453:       PetscCall(MatDestroy(&E));
454:     }
455:     PetscCall(MatDestroy(&A2));
456:   }

458:   /* Test projection operations (PtAP and RARt) */
459:   if (testproj) {
460:     PetscCall(MatPtAP(A, B, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &PtAP));
461:     PetscCall(MatPtAPMultEqual(A, B, PtAP, 10, &flg));
462:     if (!flg) {
463:       PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with PtAP\n"));
464:       PetscCall(MatMatMult(A, B, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &T));
465:       PetscCall(MatTransposeMatMult(B, T, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &T2));
466:       PetscCall(MatAXPY(T2, -1.0, PtAP, SAME_NONZERO_PATTERN));
467:       PetscCall(MatView(T2, NULL));
468:       PetscCall(MatDestroy(&T2));
469:       PetscCall(MatDestroy(&T));
470:     }
471:     PetscCall(PetscMalloc1((k + ldr) * M, &dataR));
472:     PetscCall(MatCreateDense(PETSC_COMM_WORLD, PETSC_DECIDE, m, K, M, dataR, &R));
473:     PetscCall(MatDenseSetLDA(R, k + ldr));
474:     PetscCall(MatSetRandom(R, NULL));
475:     if (testrart) { /* fails for AIJCUSPARSE because RA operation is not defined */
476:       PetscCall(MatRARt(A, R, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &RARt));
477:       PetscCall(MatRARtMultEqual(A, R, RARt, 10, &flg));
478:       if (!flg) {
479:         PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with RARt\n"));
480:         PetscCall(MatMatTransposeMult(A, R, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &T));
481:         PetscCall(MatMatMult(R, T, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &T2));
482:         PetscCall(MatAXPY(T2, -1.0, RARt, SAME_NONZERO_PATTERN));
483:         PetscCall(MatView(T2, NULL));
484:         PetscCall(MatDestroy(&T2));
485:         PetscCall(MatDestroy(&T));
486:       }
487:     }
488:   }

490:   /* Test MatDenseGetColumnVec and friends */
491:   PetscCall(MatMatMult(A, B, MAT_REUSE_MATRIX, PETSC_DETERMINE, &X));
492:   PetscCall(MatMatMult(A, B, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &T));
493:   PetscCall(MatDuplicate(T, MAT_DO_NOT_COPY_VALUES, &T2));
494:   for (k = 0; k < K; k++) {
495:     Vec Xv, Tv, T2v;

497:     PetscCall(MatDenseGetColumnVecRead(X, k, &Xv));
498:     PetscCall(MatDenseGetColumnVec(T, k, &Tv));
499:     PetscCall(MatDenseGetColumnVecWrite(T2, k, &T2v));
500:     PetscCall(VecCopy(Xv, T2v));
501:     PetscCall(VecAXPY(Tv, -1., Xv));
502:     PetscCall(MatDenseRestoreColumnVecRead(X, k, &Xv));
503:     PetscCall(MatDenseRestoreColumnVec(T, k, &Tv));
504:     PetscCall(MatDenseRestoreColumnVecWrite(T2, k, &T2v));
505:   }
506:   PetscCall(MatNorm(T, NORM_FROBENIUS, &err));
507:   if (err > PETSC_SMALL) {
508:     PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with MatDenseGetColumnVec\n"));
509:     PetscCall(MatView(T, NULL));
510:   }
511:   PetscCall(MatAXPY(T2, -1., X, SAME_NONZERO_PATTERN));
512:   PetscCall(MatNorm(T2, NORM_FROBENIUS, &err));
513:   if (err > PETSC_SMALL) {
514:     PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with MatDenseGetColumnVecWrite\n"));
515:     PetscCall(MatView(T2, NULL));
516:   }
517:   PetscCall(MatDestroy(&T));
518:   PetscCall(MatDestroy(&T2));

520:   /* Test with MatShell */
521:   PetscCall(MatDuplicate(A, MAT_COPY_VALUES, &T));
522:   PetscCall(MatConvert(T, MATSHELL, MAT_INITIAL_MATRIX, &T2));
523:   PetscCall(MatDestroy(&T));

525:   /* scale matrix */
526:   PetscCall(MatScale(A, 2.0));
527:   PetscCall(MatScale(T2, 2.0));
528:   PetscCall(MatCreateVecs(A, &r, &l));
529:   PetscCall(VecSetRandom(r, NULL));
530:   PetscCall(VecSetRandom(l, NULL));
531:   PetscCall(MatCreateVecs(T2, &rs, &ls));
532:   PetscCall(VecCopy(r, rs));
533:   PetscCall(VecCopy(l, ls));
534:   if (testproj) {
535:     PetscCall(MatDiagonalScale(A, r, r));
536:     PetscCall(MatDiagonalScale(T2, rs, rs));
537:   } else {
538:     PetscCall(MatDiagonalScale(A, l, r));
539:     PetscCall(MatDiagonalScale(T2, ls, rs));
540:   }
541:   PetscCall(MatDuplicate(A, MAT_COPY_VALUES, &T));
542:   PetscCall(MatAXPY(A, 4.5, T, SAME_NONZERO_PATTERN));
543:   PetscCall(MatAXPY(T2, 4.5, T, DIFFERENT_NONZERO_PATTERN));
544:   PetscCall(MatMultEqual(T2, A, 10, &flg));
545:   if (!flg) PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with MATSHELL (MatMult)\n"));
546:   PetscCall(MatMultTransposeEqual(T2, A, 10, &flg));
547:   if (!flg) PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with MATSHELL (MatMultTranspose)\n"));
548:   PetscCall(MatDestroy(&T));
549:   PetscCall(VecDestroy(&ls));
550:   PetscCall(VecDestroy(&rs));
551:   PetscCall(VecDestroy(&l));
552:   PetscCall(VecDestroy(&r));

554:   /* recompute projections, test reusage */
555:   if (PtAP) PetscCall(MatPtAP(A, B, MAT_REUSE_MATRIX, PETSC_DETERMINE, &PtAP));
556:   if (RARt) PetscCall(MatRARt(A, R, MAT_REUSE_MATRIX, PETSC_DETERMINE, &RARt));
557:   if (testshellops) { /* test callbacks for user defined MatProducts */
558:     PetscCall(MatShellSetMatProductOperation(T2, MATPRODUCT_AB, NULL, MyMatShellMatMultNumeric, NULL, MATDENSE, MATDENSE));
559:     PetscCall(MatShellSetMatProductOperation(T2, MATPRODUCT_AB, NULL, MyMatShellMatMultNumeric, NULL, MATDENSECUDA, MATDENSECUDA));
560:     PetscCall(MatShellSetMatProductOperation(T2, MATPRODUCT_AtB, NULL, MyMatTransposeShellMatMultNumeric, NULL, MATDENSE, MATDENSE));
561:     PetscCall(MatShellSetMatProductOperation(T2, MATPRODUCT_AtB, NULL, MyMatTransposeShellMatMultNumeric, NULL, MATDENSECUDA, MATDENSECUDA));
562:     PetscCall(MatShellSetMatProductOperation(T2, MATPRODUCT_ABt, NULL, MyMatShellMatTransposeMultNumeric, NULL, MATDENSE, MATDENSE));
563:     PetscCall(MatShellSetMatProductOperation(T2, MATPRODUCT_ABt, NULL, MyMatShellMatTransposeMultNumeric, NULL, MATDENSECUDA, MATDENSECUDA));
564:     if (testproj) {
565:       PetscCall(MatShellSetMatProductOperation(T2, MATPRODUCT_PtAP, MyPtShellPMultSymbolic, MyPtShellPMultNumeric, proj_destroy, MATDENSE, MATSHELL));
566:       PetscCall(MatShellSetMatProductOperation(T2, MATPRODUCT_PtAP, MyPtShellPMultSymbolic, MyPtShellPMultNumeric, proj_destroy, MATDENSECUDA, MATSHELL));
567:       PetscCall(MatShellSetMatProductOperation(T2, MATPRODUCT_RARt, MyRShellRtMultSymbolic, MyRShellRtMultNumeric, proj_destroy, MATDENSE, MATSHELL));
568:       PetscCall(MatShellSetMatProductOperation(T2, MATPRODUCT_RARt, MyRShellRtMultSymbolic, MyRShellRtMultNumeric, proj_destroy, MATDENSECUDA, MATSHELL));
569:     }
570:   }
571:   PetscCall(CheckLocal(B, X, aB, aX));
572:   /* we either use the shell operations or the loop over columns code, applying the operator */
573:   PetscCall(MatMatMult(T2, B, MAT_REUSE_MATRIX, PETSC_DETERMINE, &X));
574:   PetscCall(CheckLocal(B, X, aB, aX));
575:   PetscCall(MatMatMultEqual(T2, B, X, 10, &flg));
576:   if (!flg) {
577:     PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with reusage (MATSHELL)\n"));
578:     PetscCall(MatMatMult(A, B, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &T));
579:     PetscCall(MatAXPY(T, -1.0, X, SAME_NONZERO_PATTERN));
580:     PetscCall(MatView(T, NULL));
581:     PetscCall(MatDestroy(&T));
582:   }
583:   if (testproj) {
584:     PetscCall(MatPtAPMultEqual(T2, B, PtAP, 10, &flg));
585:     if (!flg) PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with PtAP (MATSHELL)\n"));
586:     if (testshellops) { /* projections fail if the product operations are not specified */
587:       PetscCall(MatPtAP(T2, B, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &T));
588:       PetscCall(MatPtAP(T2, B, MAT_REUSE_MATRIX, PETSC_DETERMINE, &T));
589:       PetscCall(MatPtAPMultEqual(T2, B, T, 10, &flg));
590:       if (!flg) {
591:         Mat TE;

593:         PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with PtAP (MATSHELL user defined)\n"));
594:         PetscCall(MatComputeOperator(T, MATDENSE, &TE));
595:         PetscCall(MatView(TE, NULL));
596:         PetscCall(MatView(PtAP, NULL));
597:         PetscCall(MatAXPY(TE, -1.0, PtAP, SAME_NONZERO_PATTERN));
598:         PetscCall(MatView(TE, NULL));
599:         PetscCall(MatDestroy(&TE));
600:       }
601:       PetscCall(MatDestroy(&T));
602:     }
603:     if (RARt) {
604:       PetscCall(MatRARtMultEqual(T2, R, RARt, 10, &flg));
605:       if (!flg) PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with RARt (MATSHELL)\n"));
606:     }
607:     if (testshellops) {
608:       PetscCall(MatRARt(T2, R, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &T));
609:       PetscCall(MatRARt(T2, R, MAT_REUSE_MATRIX, PETSC_DETERMINE, &T));
610:       PetscCall(MatRARtMultEqual(T2, R, T, 10, &flg));
611:       if (!flg) {
612:         Mat TE;

614:         PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with RARt (MATSHELL user defined)\n"));
615:         PetscCall(MatComputeOperator(T, MATDENSE, &TE));
616:         PetscCall(MatView(TE, NULL));
617:         if (RARt) {
618:           PetscCall(MatView(RARt, NULL));
619:           PetscCall(MatAXPY(TE, -1.0, RARt, SAME_NONZERO_PATTERN));
620:           PetscCall(MatView(TE, NULL));
621:         }
622:         PetscCall(MatDestroy(&TE));
623:       }
624:       PetscCall(MatDestroy(&T));
625:     }
626:   }

628:   if (testmattmat) { /* we either use the shell operations or the loop over columns code applying the transposed operator */
629:     PetscCall(MatTransposeMatMult(T2, X, MAT_REUSE_MATRIX, PETSC_DETERMINE, &B));
630:     PetscCall(CheckLocal(B, X, aB, aX));
631:     PetscCall(MatTransposeMatMultEqual(T2, X, B, 10, &flg));
632:     if (!flg) {
633:       PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with reusage (MatTranspose, MATSHELL)\n"));
634:       PetscCall(MatTransposeMatMult(A, X, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &T));
635:       PetscCall(MatAXPY(T, -1.0, B, SAME_NONZERO_PATTERN));
636:       PetscCall(MatView(T, NULL));
637:       PetscCall(MatDestroy(&T));
638:     }
639:   }
640:   if (testmatmatt && testshellops) { /* only when shell operations are set */
641:     PetscCall(MatMatTransposeMult(T2, Bt, MAT_REUSE_MATRIX, PETSC_DETERMINE, &X));
642:     PetscCall(CheckLocal(Bt, X, aBt, aX));
643:     PetscCall(MatMatTransposeMultEqual(T2, Bt, X, 10, &flg));
644:     if (!flg) {
645:       PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with reusage (MatMatTranspose, MATSHELL)\n"));
646:       PetscCall(MatMatTransposeMult(A, Bt, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &T));
647:       PetscCall(MatAXPY(T, -1.0, X, SAME_NONZERO_PATTERN));
648:       PetscCall(MatView(T, NULL));
649:       PetscCall(MatDestroy(&T));
650:     }
651:   }
652:   PetscCall(MatDestroy(&T2));

654:   if (testnest) { /* test with MatNest */
655:     Mat NA;

657:     PetscCall(MatCreateNest(PETSC_COMM_WORLD, 1, NULL, 1, NULL, &A, &NA));
658:     PetscCall(MatViewFromOptions(NA, NULL, "-NA_view"));
659:     PetscCall(MatMatMult(NA, B, MAT_REUSE_MATRIX, PETSC_DETERMINE, &X));
660:     PetscCall(CheckLocal(B, X, aB, aX));
661:     PetscCall(MatMatMultEqual(NA, B, X, 10, &flg));
662:     if (!flg) {
663:       PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with Nest\n"));
664:       PetscCall(MatMatMult(NA, B, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &T));
665:       PetscCall(MatAXPY(T, -1.0, X, SAME_NONZERO_PATTERN));
666:       PetscCall(MatView(T, NULL));
667:       PetscCall(MatDestroy(&T));
668:     }
669:     PetscCall(MatDestroy(&NA));
670:   }

672:   if (testtranspose) { /* test with Transpose */
673:     Mat TA;

675:     PetscCall(MatCreateTranspose(A, &TA));
676:     PetscCall(MatMatMult(TA, X, MAT_REUSE_MATRIX, PETSC_DETERMINE, &B));
677:     PetscCall(CheckLocal(B, X, aB, aX));
678:     PetscCall(MatMatMultEqual(TA, X, B, 10, &flg));
679:     if (!flg) {
680:       PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with Transpose\n"));
681:       PetscCall(MatMatMult(TA, X, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &T));
682:       PetscCall(MatAXPY(T, -1.0, B, SAME_NONZERO_PATTERN));
683:       PetscCall(MatView(T, NULL));
684:       PetscCall(MatDestroy(&T));
685:     }
686:     PetscCall(MatDestroy(&TA));
687:   }

689:   if (testhtranspose) { /* test with Hermitian Transpose */
690:     Mat TA;

692:     PetscCall(MatCreateHermitianTranspose(A, &TA));
693:     PetscCall(MatMatMult(TA, X, MAT_REUSE_MATRIX, PETSC_DETERMINE, &B));
694:     PetscCall(CheckLocal(B, X, aB, aX));
695:     PetscCall(MatMatMultEqual(TA, X, B, 10, &flg));
696:     if (!flg) {
697:       PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with Transpose\n"));
698:       PetscCall(MatMatMult(TA, X, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &T));
699:       PetscCall(MatAXPY(T, -1.0, B, SAME_NONZERO_PATTERN));
700:       PetscCall(MatView(T, NULL));
701:       PetscCall(MatDestroy(&T));
702:     }
703:     PetscCall(MatDestroy(&TA));
704:   }

706:   if (testtt) { /* test with Transpose(Transpose) */
707:     Mat TA, TTA;

709:     PetscCall(MatCreateTranspose(A, &TA));
710:     PetscCall(MatCreateTranspose(TA, &TTA));
711:     PetscCall(MatMatMult(TTA, B, MAT_REUSE_MATRIX, PETSC_DETERMINE, &X));
712:     PetscCall(CheckLocal(B, X, aB, aX));
713:     PetscCall(MatMatMultEqual(TTA, B, X, 10, &flg));
714:     if (!flg) {
715:       PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with Transpose(Transpose)\n"));
716:       PetscCall(MatMatMult(TTA, B, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &T));
717:       PetscCall(MatAXPY(T, -1.0, X, SAME_NONZERO_PATTERN));
718:       PetscCall(MatView(T, NULL));
719:       PetscCall(MatDestroy(&T));
720:     }
721:     PetscCall(MatDestroy(&TA));
722:     PetscCall(MatDestroy(&TTA));
723:   }

725:   if (testcircular) { /* test circular */
726:     Mat AB;

728:     PetscCall(MatMatMult(A, B, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &AB));
729:     PetscCall(MatMatMult(A, B, MAT_REUSE_MATRIX, PETSC_DETERMINE, &X));
730:     PetscCall(CheckLocal(B, X, aB, aX));
731:     if (M == N && N == K) PetscCall(MatMatMult(A, X, MAT_REUSE_MATRIX, PETSC_DETERMINE, &B));
732:     else PetscCall(MatTransposeMatMult(A, X, MAT_REUSE_MATRIX, PETSC_DETERMINE, &B));
733:     PetscCall(CheckLocal(B, X, aB, aX));
734:     PetscCall(MatDestroy(&AB));
735:   }

737:   /* Test by Pierre Jolivet */
738:   {
739:     Mat C, D, D2, AtA;
740:     PetscCall(MatCreateNormal(A, &AtA));
741:     PetscCall(MatDuplicate(X, MAT_DO_NOT_COPY_VALUES, &C));
742:     PetscCall(MatDuplicate(B, MAT_DO_NOT_COPY_VALUES, &D));
743:     PetscCall(MatDuplicate(B, MAT_DO_NOT_COPY_VALUES, &D2));
744:     PetscCall(MatSetRandom(B, NULL));
745:     PetscCall(MatSetRandom(C, NULL));
746:     PetscCall(MatSetRandom(D, NULL));
747:     PetscCall(MatSetRandom(D2, NULL));
748:     PetscCall(MatProductCreateWithMat(A, B, NULL, C));
749:     PetscCall(MatProductSetType(C, MATPRODUCT_AB));
750:     PetscCall(MatProductSetFromOptions(C));
751:     PetscCall(MatProductSymbolic(C));
752:     PetscCall(MatProductCreateWithMat(A, C, NULL, D));
753:     PetscCall(MatProductSetType(D, MATPRODUCT_AtB));
754:     PetscCall(MatProductSetFromOptions(D));
755:     PetscCall(MatProductSymbolic(D));
756:     PetscCall(MatProductNumeric(C));
757:     PetscCall(MatMatMultEqual(A, B, C, 10, &flg));
758:     if (!flg) {
759:       PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with Normal (AB != C)\n"));
760:       PetscCall(MatView(A, NULL));
761:       PetscCall(MatView(B, NULL));
762:       PetscCall(MatView(C, NULL));
763:     }
764:     PetscCall(MatProductNumeric(D));
765:     PetscCall(MatMatMultEqual(AtA, B, D, 10, &flg));
766:     if (!flg) {
767:       PetscCall(PetscPrintf(PETSC_COMM_WORLD, "Error with Normal (2)\n"));
768:       PetscCall(MatMatMult(AtA, C, MAT_INITIAL_MATRIX, PETSC_DETERMINE, &T));
769:       PetscCall(MatView(D, NULL));
770:       PetscCall(MatView(T, NULL));
771:       PetscCall(MatAXPY(T, -1.0, D, SAME_NONZERO_PATTERN));
772:       PetscCall(MatView(T, NULL));
773:       PetscCall(MatDestroy(&T));
774:     }
775:     PetscCall(MatDestroy(&C));
776:     PetscCall(MatDestroy(&D));
777:     PetscCall(MatDestroy(&D2));
778:     PetscCall(MatDestroy(&AtA));
779:   }

781:   PetscCall(MatDestroy(&X));
782:   PetscCall(MatDestroy(&Bt));
783:   PetscCall(MatDestroy(&B));
784:   PetscCall(MatDestroy(&A));
785:   PetscCall(MatDestroy(&R));
786:   PetscCall(MatDestroy(&PtAP));
787:   PetscCall(MatDestroy(&RARt));
788:   PetscCall(PetscFree(dataX));
789:   PetscCall(PetscFree(dataB));
790:   PetscCall(PetscFree(dataR));
791:   PetscCall(PetscFree(dataBt));
792:   PetscCall(PetscFinalize());
793:   return 0;
794: }

796: /*TEST

798:   test:
799:     output_file: output/empty.out
800:     suffix: 1
801:     args: -local {{0 1}} -testshellops

803:   test:
804:     output_file: output/empty.out
805:     requires: cuda
806:     suffix: 1_cuda
807:     args: -local {{0 1}} -xgpu {{0 1}} -bgpu {{0 1}} -A_mat_type {{seqaijcusparse seqaij}} -testshellops {{0 1}}

809:   # RARt is skipped for aijkokkos because the R*A products with a dense R it needs are not defined
810:   # -xgpu and -bgpu are not used with aijkokkos because the checks in MatMatMultEqual() and friends cannot
811:   # copy between the VECCUDA of a MATDENSECUDA operand and the VECKOKKOS of an aijkokkos matrix
812:   test:
813:     output_file: output/empty.out
814:     requires: kokkos_kernels
815:     suffix: 1_kokkos
816:     args: -local {{0 1}} -A_mat_type aijkokkos -testrart 0 -A_form_explicit_transpose {{0 1}}

818:   test:
819:     output_file: output/empty.out
820:     nsize: 2
821:     suffix: 1_par
822:     args: -local {{0 1}} -testmatmatt 0

824:   test:
825:     output_file: output/empty.out
826:     nsize: 2
827:     requires: kokkos_kernels
828:     suffix: 1_par_kokkos
829:     args: -local {{0 1}} -testmatmatt 0 -A_mat_type aijkokkos -testrart 0

831:   test:
832:     output_file: output/empty.out
833:     suffix: 1_reuse
834:     args: -testreusemodified

836:   test:
837:     output_file: output/empty.out
838:     nsize: 2
839:     suffix: 1_par_reuse
840:     args: -testmatmatt 0 -testreusemodified

842:   test:
843:     output_file: output/empty.out
844:     nsize: 2
845:     requires: kokkos_kernels
846:     suffix: 1_par_kokkos_reuse
847:     args: -testmatmatt 0 -A_mat_type aijkokkos -testrart 0 -testreusemodified

849:   test:
850:     output_file: output/empty.out
851:     nsize: 2
852:     requires: cuda
853:     suffix: 1_par_cuda_reuse
854:     args: -testnest 0 -testmatmatt 0 -matproduct_batch_size 3 -A_mat_type mpiaijcusparse -testreusemodified

856:   test:
857:     output_file: output/empty.out
858:     requires: cuda
859:     nsize: 2
860:     suffix: 1_par_cuda
861:     args: -local {{0 1}} -xgpu {{0 1}} -bgpu {{0 1}} -A_mat_type {{mpiaijcusparse mpiaij}} -testnest 0 -testmatmatt 0 -matproduct_batch_size 3

863:   test:
864:     output_file: output/empty.out
865:     suffix: 2
866:     nsize: 1
867:     args: -M {{7 11}} -N {{12 9}} -K {{1 3}} -local {{0 1}}

869:   testset:
870:     requires: cuda
871:     output_file: output/empty.out
872:     nsize: 1
873:     args: -M 7 -N 9 -K 2 -local {{0 1}} -testnest 0 -A_mat_type {{seqdensecuda seqdense}} -xgpu {{0 1}} -bgpu {{0 1}}
874:     test:
875:       requires: !complex
876:       suffix: 2_cuda_real
877:     test:
878:       # complex+single gives a little bigger error in the MatDenseGetColumnVec test
879:       requires: complex !single
880:       suffix: 2_cuda_complex

882:   test:
883:     output_file: output/empty.out
884:     suffix: 2_par
885:     nsize: 2
886:     args: -M {{7 11}} -N {{12 9}} -K {{1 3}} -local {{0 1}} -testcircular -testmatmatt 0

888:   test:
889:     requires: cuda
890:     output_file: output/empty.out
891:     suffix: 2_par_cuda
892:     nsize: 2
893:     args: -M 11 -N 9 -K 1 -local {{0 1}} -testcircular 0 -A_mat_type mpiaijcusparse -xgpu -bgpu -testnest 0 -testmatmatt 0

895:   test:
896:     output_file: output/empty.out
897:     suffix: 3
898:     nsize: {{1 3}}
899:     args: -M 13 -N 13 -K {{1 3}} -local {{0 1}} -A_mat_type sbaij -symm -testproj 0 -testmatmatt 0

901:   test:
902:     output_file: output/empty.out
903:     suffix: 4
904:     nsize: 1
905:     args: -M 3 -N 3 -K 3 -local {{0 1}} -testcircular

907:   test:
908:     output_file: output/empty.out
909:     suffix: 5
910:     nsize: {{2 4}}
911:     args: -M 3 -N 3 -K 3 -local {{0 1}} -testcircular -testmatmatt 0

913:   test:
914:     output_file: output/empty.out
915:     suffix: 6
916:     nsize: 1
917:     args: -M {{1 3}} -N {{2 5}} -K {{1 2}} -local {{0 1}} -testcircular

919:   test:
920:     output_file: output/empty.out
921:     suffix: 7
922:     nsize: 1
923:     args: -M 13 -N 13 -K {{1 3}} -local {{0 1}} -A_mat_type dense -testnest -testcircular

925: TEST*/