Actual source code: ex48.c

  2: static char help[] = "Tests the vatious routines in MatBAIJ format.\n";

 4:  #include petscmat.h

  8: int main(int argc,char **args)
  9: {
 10:   Mat             A,B;
 11:   Vec             xx,s1,s2,yy;
 13:   PetscInt        m=45,rows[2],cols[2],bs=1,i,row,col,*idx,M;
 14:   PetscScalar     rval,vals1[4],vals2[4],zero=0.0,neg_one=-1.0;
 15:   PetscRandom     rdm;
 16:   IS              is1,is2;
 17:   PetscReal       s1norm,s2norm,rnorm,tol = 1.e-8;
 18:   PetscTruth      flg;
 19:   MatFactorInfo   info;
 20: 
 21:   PetscInitialize(&argc,&args,(char *)0,help);
 22: 
 23:   /* Test MatSetValues() and MatGetValues() */
 24:   PetscOptionsGetInt(PETSC_NULL,"-mat_block_size",&bs,PETSC_NULL);
 25:   PetscOptionsGetInt(PETSC_NULL,"-mat_size",&m,PETSC_NULL);
 26:   M    = m*bs;
 27:   MatCreateSeqBAIJ(PETSC_COMM_SELF,bs,M,M,1,PETSC_NULL,&A);
 28:   MatCreateSeqAIJ(PETSC_COMM_SELF,M,M,15,PETSC_NULL,&B);
 29:   PetscRandomCreate(PETSC_COMM_SELF,RANDOM_DEFAULT,&rdm);
 30:   VecCreateSeq(PETSC_COMM_SELF,M,&xx);
 31:   VecDuplicate(xx,&s1);
 32:   VecDuplicate(xx,&s2);
 33:   VecDuplicate(xx,&yy);
 34: 
 35:   /* For each row add atleast 15 elements */
 36:   for (row=0; row<M; row++) {
 37:     for (i=0; i<25*bs; i++) {
 38:       PetscRandomGetValue(rdm,&rval);
 39:       col  = (PetscInt)(PetscRealPart(rval)*M);
 40:       MatSetValues(A,1,&row,1,&col,&rval,ADD_VALUES);
 41:       MatSetValues(B,1,&row,1,&col,&rval,ADD_VALUES);
 42:     }
 43:   }
 44: 
 45:   /* Now set blocks of values */
 46:   for (i=0; i<20*bs; i++) {
 47:     PetscRandomGetValue(rdm,&rval);
 48:     cols[0] = (PetscInt)(PetscRealPart(rval)*M);
 49:     vals1[0] = rval;
 50:     PetscRandomGetValue(rdm,&rval);
 51:     cols[1] = (PetscInt)(PetscRealPart(rval)*M);
 52:     vals1[1] = rval;
 53:     PetscRandomGetValue(rdm,&rval);
 54:     rows[0] = (PetscInt)(PetscRealPart(rval)*M);
 55:     vals1[2] = rval;
 56:     PetscRandomGetValue(rdm,&rval);
 57:     rows[1] = (PetscInt)(PetscRealPart(rval)*M);
 58:     vals1[3] = rval;
 59:     MatSetValues(A,2,rows,2,cols,vals1,ADD_VALUES);
 60:     MatSetValues(B,2,rows,2,cols,vals1,ADD_VALUES);
 61:   }
 62: 
 63:   MatAssemblyBegin(A,MAT_FINAL_ASSEMBLY);
 64:   MatAssemblyEnd(A,MAT_FINAL_ASSEMBLY);
 65:   MatAssemblyBegin(B,MAT_FINAL_ASSEMBLY);
 66:   MatAssemblyEnd(B,MAT_FINAL_ASSEMBLY);
 67: 
 68:   /* Test MatNorm() */
 69:   MatNorm(A,NORM_FROBENIUS,&s1norm);
 70:   MatNorm(B,NORM_FROBENIUS,&s2norm);
 71:   rnorm = s2norm-s1norm;
 72:   if (rnorm<-tol || rnorm>tol) {
 73:     PetscPrintf(PETSC_COMM_SELF,"Error: MatNorm()- Norm1=%16.14e Norm2=%16.14e bs = %D\n",s1norm,s2norm,bs);
 74:   }
 75:   /* MatScale() */
 76:   rval = 10*s1norm;
 77:   MatShift(&rval,A);
 78:   MatShift(&rval,B);
 79: 
 80:   /* Test MatTranspose() */
 81:   MatTranspose(A,PETSC_NULL);
 82:   MatTranspose(B,PETSC_NULL);
 83: 
 84: 
 85:   /* Now do MatGetValues()  */
 86:   for (i=0; i<30; i++) {
 87:     PetscRandomGetValue(rdm,&rval);
 88:     cols[0] = (PetscInt)(PetscRealPart(rval)*M);
 89:     PetscRandomGetValue(rdm,&rval);
 90:     cols[1] = (PetscInt)(PetscRealPart(rval)*M);
 91:     PetscRandomGetValue(rdm,&rval);
 92:     rows[0] = (PetscInt)(PetscRealPart(rval)*M);
 93:     PetscRandomGetValue(rdm,&rval);
 94:     rows[1] = (PetscInt)(PetscRealPart(rval)*M);
 95:     MatGetValues(A,2,rows,2,cols,vals1);
 96:     MatGetValues(B,2,rows,2,cols,vals2);
 97:     PetscMemcmp(vals1,vals2,4*sizeof(PetscScalar),&flg);
 98:     if (!flg) {
 99:       PetscPrintf(PETSC_COMM_SELF,"Error: MatGetValues bs = %D\n",bs);
100:     }
101:   }
102: 
103:   /* Test MatMult(), MatMultAdd() */
104:   for (i=0; i<40; i++) {
105:     VecSetRandom(rdm,xx);
106:     VecSet(&zero,s2);
107:     MatMult(A,xx,s1);
108:     MatMultAdd(A,xx,s2,s2);
109:     VecNorm(s1,NORM_2,&s1norm);
110:     VecNorm(s2,NORM_2,&s2norm);
111:     rnorm = s2norm-s1norm;
112:     if (rnorm<-tol || rnorm>tol) {
113:       PetscPrintf(PETSC_COMM_SELF,"MatMult not equal to MatMultAdd Norm1=%e Norm2=%e bs = %D\n",s1norm,s2norm,bs);
114:     }
115:   }

117:   /* Test MatMult() */
118:   for (i=0; i<40; i++) {
119:     VecSetRandom(rdm,xx);
120:     MatMult(A,xx,s1);
121:     MatMult(B,xx,s2);
122:     VecAXPY(&neg_one,s1,s2);
123:     VecNorm(s2,NORM_1,&s2norm);
124:     if (s2norm >tol) {
125:       PetscPrintf(PETSC_COMM_SELF,"Error: MatMult(), ||s1-s2||=%g\n",s2norm);
126:     }
127:     /*
128:     VecNorm(s1,NORM_2,&s1norm);
129:     VecNorm(s2,NORM_2,&s2norm);
130:     rnorm = s2norm-s1norm;
131:     if (rnorm<-tol || rnorm>tol) { 
132:       PetscPrintf(PETSC_COMM_SELF,"Error:MatMult - Norm1=%16.14e Norm2=%16.14e bs = %D \n",s1norm,s2norm,bs);
133:     */
134:   }
135: 
136:   /* Test MatMultAdd() */
137:   for (i=0; i<40; i++) {
138:     VecSetRandom(rdm,xx);
139:     VecSetRandom(rdm,yy);
140:     MatMultAdd(A,xx,yy,s1);
141:     MatMultAdd(B,xx,yy,s2);
142:     VecAXPY(&neg_one,s1,s2);
143:     VecNorm(s2,NORM_1,&s2norm);
144:     if (s2norm >tol) {
145:       PetscPrintf(PETSC_COMM_SELF,"Error: MatMultAdd(), ||s1-s2||=%g\n",s2norm);
146:     }
147:     /*
148:     VecNorm(s1,NORM_2,&s1norm);
149:     VecNorm(s2,NORM_2,&s2norm);
150:     rnorm = s2norm-s1norm;
151:     if (rnorm<-tol || rnorm>tol) { 
152:       PetscPrintf(PETSC_COMM_SELF,"Error:MatMultAdd - Norm1=%16.14e Norm2=%16.14e bs = %D\n",s1norm,s2norm,bs);
153:     } 
154:     */
155:   }
156: 
157:   /* Test MatMultTranspose() */
158:   for (i=0; i<40; i++) {
159:     VecSetRandom(rdm,xx);
160:     MatMultTranspose(A,xx,s1);
161:     MatMultTranspose(B,xx,s2);
162:     VecNorm(s1,NORM_2,&s1norm);
163:     VecNorm(s2,NORM_2,&s2norm);
164:     rnorm = s2norm-s1norm;
165:     if (rnorm<-tol || rnorm>tol) {
166:       PetscPrintf(PETSC_COMM_SELF,"Error: MatMultTranspose - Norm1=%16.14e Norm2=%16.14e bs = %D\n",s1norm,s2norm,bs);
167:     }
168:   }
169:   /* Test MatMultTransposeAdd() */
170:   for (i=0; i<40; i++) {
171:     VecSetRandom(rdm,xx);
172:     VecSetRandom(rdm,yy);
173:     MatMultTransposeAdd(A,xx,yy,s1);
174:     MatMultTransposeAdd(B,xx,yy,s2);
175:     VecNorm(s1,NORM_2,&s1norm);
176:     VecNorm(s2,NORM_2,&s2norm);
177:     rnorm = s2norm-s1norm;
178:     if (rnorm<-tol || rnorm>tol) {
179:       PetscPrintf(PETSC_COMM_SELF,"Error:MatMultTransposeAdd - Norm1=%16.14e Norm2=%16.14e bs = %D\n",s1norm,s2norm,bs);
180:     }
181:   }
182: 
183: 
184:   /* Do LUFactor() on both the matrices */
185:   PetscMalloc(M*sizeof(PetscInt),&idx);
186:   for (i=0; i<M; i++) idx[i] = i;
187:   ISCreateGeneral(PETSC_COMM_SELF,M,idx,&is1);
188:   ISCreateGeneral(PETSC_COMM_SELF,M,idx,&is2);
189:   PetscFree(idx);
190:   ISSetPermutation(is1);
191:   ISSetPermutation(is2);

193:   MatFactorInfoInitialize(&info);
194:   info.fill = 2.0;
195:   info.dtcol = 0.0;
196:   info.damping = 0.0;
197:   info.zeropivot = 1.e-14;
198:   info.pivotinblocks = 1.0;
199:   MatLUFactor(B,is1,is2,&info);
200:   MatLUFactor(A,is1,is2,&info);
201: 
202:   /* Test MatSolveAdd() */
203:   for (i=0; i<40; i++) {
204:     VecSetRandom(rdm,xx);
205:     VecSetRandom(rdm,yy);
206:     MatSolveAdd(B,xx,yy,s2);
207:     MatSolveAdd(A,xx,yy,s1);
208:     VecNorm(s1,NORM_2,&s1norm);
209:     VecNorm(s2,NORM_2,&s2norm);
210:     rnorm = s2norm-s1norm;
211:     if (rnorm<-tol || rnorm>tol) {
212:       PetscPrintf(PETSC_COMM_SELF,"Error:MatSolveAdd - Norm1=%16.14e Norm2=%16.14e bs = %D\n",s1norm,s2norm,bs);
213:     }
214:   }
215: 
216:   /* Test MatSolveAdd() when x = A'b +x */
217:   for (i=0; i<40; i++) {
218:     VecSetRandom(rdm,xx);
219:     VecSetRandom(rdm,s1);
220:     VecCopy(s2,s1);
221:     MatSolveAdd(B,xx,s2,s2);
222:     MatSolveAdd(A,xx,s1,s1);
223:     VecNorm(s1,NORM_2,&s1norm);
224:     VecNorm(s2,NORM_2,&s2norm);
225:     rnorm = s2norm-s1norm;
226:     if (rnorm<-tol || rnorm>tol) {
227:       PetscPrintf(PETSC_COMM_SELF,"Error:MatSolveAdd(same) - Norm1=%16.14e Norm2=%16.14e bs = %D\n",s1norm,s2norm,bs);
228:     }
229:   }
230: 
231:   /* Test MatSolve() */
232:   for (i=0; i<40; i++) {
233:     VecSetRandom(rdm,xx);
234:     MatSolve(B,xx,s2);
235:     MatSolve(A,xx,s1);
236:     VecNorm(s1,NORM_2,&s1norm);
237:     VecNorm(s2,NORM_2,&s2norm);
238:     rnorm = s2norm-s1norm;
239:     if (rnorm<-tol || rnorm>tol) {
240:       PetscPrintf(PETSC_COMM_SELF,"Error:MatSolve - Norm1=%16.14e Norm2=%16.14e bs = %D\n",s1norm,s2norm,bs);
241:     }
242:   }
243: 
244:   /* Test MatSolveTranspose() */
245:   if (bs < 8) {
246:     for (i=0; i<40; i++) {
247:       VecSetRandom(rdm,xx);
248:       MatSolveTranspose(B,xx,s2);
249:       MatSolveTranspose(A,xx,s1);
250:       VecNorm(s1,NORM_2,&s1norm);
251:       VecNorm(s2,NORM_2,&s2norm);
252:       rnorm = s2norm-s1norm;
253:       if (rnorm<-tol || rnorm>tol) {
254:         PetscPrintf(PETSC_COMM_SELF,"Error:MatSolveTranspose - Norm1=%16.14e Norm2=%16.14e bs = %D\n",s1norm,s2norm,bs);
255:       }
256:     }
257:   }

259:   MatDestroy(A);
260:   MatDestroy(B);
261:   VecDestroy(xx);
262:   VecDestroy(s1);
263:   VecDestroy(s2);
264:   VecDestroy(yy);
265:   ISDestroy(is1);
266:   ISDestroy(is2);
267:   PetscRandomDestroy(rdm);
268:   PetscFinalize();
269:   return 0;
270: }