Actual source code: ex48.c

  2: static char help[] = "Tests the vatious routines in MatSeqBAIJ 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;
 15:   PetscRandom     rdm;
 16:   IS              is1,is2;
 17:   PetscReal       s1norm,s2norm,rnorm,tol = 1.e-4;
 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,INSERT_VALUES);
 41:       MatSetValues(B,1,&row,1,&col,&rval,INSERT_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,INSERT_VALUES);
 60:     MatSetValues(B,2,rows,2,cols,vals1,INSERT_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 = PetscAbsScalar(s2norm-s1norm)/s2norm;
 72:   if ( rnorm>tol ) {
 73:     PetscPrintf(PETSC_COMM_SELF,"Error: MatNorm_FROBENIUS()- NormA=%16.14e NormB=%16.14e bs = %D\n",s1norm,s2norm,bs);
 74:   }
 75:   MatNorm(A,NORM_INFINITY,&s1norm);
 76:   MatNorm(B,NORM_INFINITY,&s2norm);
 77:   rnorm = PetscAbsScalar(s2norm-s1norm)/s2norm;
 78:   if ( rnorm>tol ) {
 79:     PetscPrintf(PETSC_COMM_SELF,"Error: MatNorm_INFINITY()- NormA=%16.14e NormB=%16.14e bs = %D\n",s1norm,s2norm,bs);
 80:   }
 81:   MatNorm(A,NORM_1,&s1norm);
 82:   MatNorm(B,NORM_1,&s2norm);
 83:   rnorm = PetscAbsScalar(s2norm-s1norm)/s2norm;
 84:   if ( rnorm>tol ) {
 85:     PetscPrintf(PETSC_COMM_SELF,"Error: MatNorm_NORM_1()- NormA=%16.14e NormB=%16.14e bs = %D\n",s1norm,s2norm,bs);
 86:   }

 88:   /* MatShift() */
 89:   rval = 10*s1norm;
 90:   MatShift(A,rval);
 91:   MatShift(B,rval);

 93:   /* Test MatTranspose() */
 94:   MatTranspose(A,PETSC_NULL);
 95:   MatTranspose(B,PETSC_NULL);

 97:   /* Now do MatGetValues()  */
 98:   for (i=0; i<30; i++) {
 99:     PetscRandomGetValue(rdm,&rval);
100:     cols[0] = (PetscInt)(PetscRealPart(rval)*M);
101:     PetscRandomGetValue(rdm,&rval);
102:     cols[1] = (PetscInt)(PetscRealPart(rval)*M);
103:     PetscRandomGetValue(rdm,&rval);
104:     rows[0] = (PetscInt)(PetscRealPart(rval)*M);
105:     PetscRandomGetValue(rdm,&rval);
106:     rows[1] = (PetscInt)(PetscRealPart(rval)*M);
107:     MatGetValues(A,2,rows,2,cols,vals1);
108:     MatGetValues(B,2,rows,2,cols,vals2);
109:     PetscMemcmp(vals1,vals2,4*sizeof(PetscScalar),&flg);
110:     if (!flg) {
111:       PetscPrintf(PETSC_COMM_SELF,"Error: MatGetValues bs = %D\n",bs);
112:     }
113:   }
114: 
115:   /* Test MatMult(), MatMultAdd() */
116:   for (i=0; i<40; i++) {
117:     VecSetRandom(xx,rdm);
118:     VecSet(s2,zero);
119:     MatMult(A,xx,s1);
120:     MatMultAdd(A,xx,s2,s2);
121:     VecNorm(s1,NORM_2,&s1norm);
122:     VecNorm(s2,NORM_2,&s2norm);
123:     rnorm = s2norm-s1norm;
124:     if (rnorm<-tol || rnorm>tol) {
125:       PetscPrintf(PETSC_COMM_SELF,"MatMult not equal to MatMultAdd Norm1=%e Norm2=%e bs = %D\n",s1norm,s2norm,bs);
126:     }
127:   }

129:   /* Test MatMult() */
130:   MatMultEqual(A,B,10,&flg);
131:   if (!flg){
132:     PetscPrintf(PETSC_COMM_SELF,"Error: MatMult()\n");
133:   }
134: 
135:   /* Test MatMultAdd() */
136:   MatMultAddEqual(A,B,10,&flg);
137:   if (!flg){
138:     PetscPrintf(PETSC_COMM_SELF,"Error: MatMultAdd()\n");
139:   }
140: 
141:   /* Test MatMultTranspose() */
142:   MatMultTransposeEqual(A,B,10,&flg);
143:   if (!flg){
144:     PetscPrintf(PETSC_COMM_SELF,"Error: MatMultTranspose()\n");
145:   }

147:   /* Test MatMultTransposeAdd() */
148:   MatMultTransposeAddEqual(A,B,10,&flg);
149:   if (!flg){
150:     PetscPrintf(PETSC_COMM_SELF,"Error: MatMultTransposeAdd()\n");
151:   }

153:   /* Do LUFactor() on both the matrices */
154:   PetscMalloc(M*sizeof(PetscInt),&idx);
155:   for (i=0; i<M; i++) idx[i] = i;
156:   ISCreateGeneral(PETSC_COMM_SELF,M,idx,&is1);
157:   ISCreateGeneral(PETSC_COMM_SELF,M,idx,&is2);
158:   PetscFree(idx);
159:   ISSetPermutation(is1);
160:   ISSetPermutation(is2);

162:   MatFactorInfoInitialize(&info);
163:   info.fill      = 2.0;
164:   info.dtcol     = 0.0;
165:   info.shiftnz   = 0.0;
166:   info.zeropivot = 1.e-14;
167:   info.pivotinblocks = 1.0;
168:   MatLUFactor(B,is1,is2,&info);
169:   MatLUFactor(A,is1,is2,&info);
170: 
171:   /* Test MatSolveAdd() */
172:   for (i=0; i<10; i++) {
173:     VecSetRandom(xx,rdm);
174:     VecSetRandom(yy,rdm);
175:     MatSolveAdd(B,xx,yy,s2);
176:     MatSolveAdd(A,xx,yy,s1);
177:     VecNorm(s1,NORM_2,&s1norm);
178:     VecNorm(s2,NORM_2,&s2norm);
179:     rnorm = s2norm-s1norm;
180:     if (rnorm<-tol || rnorm>tol) {
181:       PetscPrintf(PETSC_COMM_SELF,"Error:MatSolveAdd - Norm1=%16.14e Norm2=%16.14e bs = %D\n",s1norm,s2norm,bs);
182:     }
183:   }
184: 
185:   /* Test MatSolveAdd() when x = A'b +x */
186:   for (i=0; i<10; i++) {
187:     VecSetRandom(xx,rdm);
188:     VecSetRandom(s1,rdm);
189:     VecCopy(s2,s1);
190:     MatSolveAdd(B,xx,s2,s2);
191:     MatSolveAdd(A,xx,s1,s1);
192:     VecNorm(s1,NORM_2,&s1norm);
193:     VecNorm(s2,NORM_2,&s2norm);
194:     rnorm = s2norm-s1norm;
195:     if (rnorm<-tol || rnorm>tol) {
196:       PetscPrintf(PETSC_COMM_SELF,"Error:MatSolveAdd(same) - Norm1=%16.14e Norm2=%16.14e bs = %D\n",s1norm,s2norm,bs);
197:     }
198:   }
199: 
200:   /* Test MatSolve() */
201:   for (i=0; i<10; i++) {
202:     VecSetRandom(xx,rdm);
203:     MatSolve(B,xx,s2);
204:     MatSolve(A,xx,s1);
205:     VecNorm(s1,NORM_2,&s1norm);
206:     VecNorm(s2,NORM_2,&s2norm);
207:     rnorm = s2norm-s1norm;
208:     if (rnorm<-tol || rnorm>tol) {
209:       PetscPrintf(PETSC_COMM_SELF,"Error:MatSolve - Norm1=%16.14e Norm2=%16.14e bs = %D\n",s1norm,s2norm,bs);
210:     }
211:   }
212: 
213:   /* Test MatSolveTranspose() */
214:   if (bs < 8) {
215:     for (i=0; i<10; i++) {
216:       VecSetRandom(xx,rdm);
217:       MatSolveTranspose(B,xx,s2);
218:       MatSolveTranspose(A,xx,s1);
219:       VecNorm(s1,NORM_2,&s1norm);
220:       VecNorm(s2,NORM_2,&s2norm);
221:       rnorm = s2norm-s1norm;
222:       if (rnorm<-tol || rnorm>tol) {
223:         PetscPrintf(PETSC_COMM_SELF,"Error:MatSolveTranspose - Norm1=%16.14e Norm2=%16.14e bs = %D\n",s1norm,s2norm,bs);
224:       }
225:     }
226:   }

228:   MatDestroy(A);
229:   MatDestroy(B);
230:   VecDestroy(xx);
231:   VecDestroy(s1);
232:   VecDestroy(s2);
233:   VecDestroy(yy);
234:   ISDestroy(is1);
235:   ISDestroy(is2);
236:   PetscRandomDestroy(rdm);
237:   PetscFinalize();
238:   return 0;
239: }